diseño modular con verilog. - inicio · departamento …lsb/elo211/clases/disenomodular2.pdf · 1...
TRANSCRIPT
1
Profesor Leopoldo Silva Bijit 19-01-2010
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.
f1
f2
a
b c
d
2
2
2
2
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);
}
2 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
//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
Profesor Leopoldo Silva Bijit 19-01-2010
#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
00000001 01
00000010 01
00000011 01
00000100 01
00000101 01
00000110 01
00000111 01
00001000 01
00001001 01
00001010 01
00001011 01
00001100 01
00001101 01
00001110 01
00001111 01
00010000 01
00010001 01
00010010 01
00010011 01
00010100 01
00010101 01
00010110 01
00010111 01
00011000 01
00011001 01
00011010 01
00011011 01
00011100 01
00011101 01
00011110 01
00011111 01
00100000 01
00100001 01
00100010 01
00100011 01
00100100 01
00100101 01
00100110 01
00100111 01
00101000 01
00101001 01
00101010 01
00101011 01
00101100 01
00101101 01
00101110 01
00101111 01
00110000 01
00110001 01
00110010 01
00110011 01
00110100 01
00110101 01
00110110 01
00110111 01
00111000 01
00111001 01
00111010 01
00111011 01
00111100 01
00111101 01
00111110 01
00111111 01
01000000 00
01000001 00
01000010 01
01000011 01
01000100 01
01000101 01
01000110 01
01000111 01
01001000 01
01001001 01
01001010 01
01001011 01
01001100 01
01001101 01
01001110 01
01001111 01
01010000 00
01010001 00
01010010 01
01010011 01
01010100 01
01010101 01
01010110 01
01010111 01
01011000 01
01011001 01
01011010 01
01011011 01
01011100 01
01011101 01
01011110 01
01011111 01
01100000 00
01100001 00
01100010 01
01100011 01
01100100 01
01100101 01
01100110 01
01100111 01
01101000 01
01101001 01
01101010 01
01101011 01
01101100 01
01101101 01
01101110 01
01101111 01
01110000 00
01110001 00
01110010 01
01110011 01
01110100 01
01110101 01
01110110 01
01110111 01
01111000 01
01111001 01
01111010 01
01111011 01
01111100 01
01111101 01
01111110 01
01111111 01
10000000 00
10000001 00
10000010 00
10000011 01
10000100 00
10000101 00
10000110 00
10000111 01
10001000 01
10001001 01
10001010 01
10001011 01
10001100 01
10001101 01
10001110 01
10001111 01
10010000 00
10010001 00
10010010 00
10010011 01
10010100 00
10010101 00
10010110 00
10010111 01
10011000 01
10011001 01
10011010 01
10011011 01
10011100 01
10011101 01
10011110 01
10011111 01
10100000 00
10100001 00
10100010 00
10100011 01
10100100 00
10100101 00
10100110 00
10100111 01
10101000 01
10101001 01
10101010 01
10101011 01
10101100 01
10101101 01
10101110 01
10101111 01
2 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
10110000 00
10110001 00
10110010 00
10110011 01
10110100 00
10110101 00
10110110 00
10110111 01
10111000 01
10111001 01
10111010 01
10111011 01
10111100 01
10111101 01
10111110 01
10111111 01
11000000 00
11000001 00
11000010 00
11000011 00
11000100 00
11000101 00
11000110 00
11000111 00
11001000 00
11001001 00
11001010 00
11001011 00
11001100 01
11001101 01
11001110 01
11001111 01
11010000 00
11010001 00
11010010 00
11010011 00
11010100 00
11010101 00
11010110 00
11010111 00
11011000 00
11011001 00
11011010 00
11011011 00
11011100 01
11011101 01
11011110 01
11011111 01
11100000 00
11100001 00
11100010 00
11100011 00
11100100 10
11100101 00
11100110 00
11100111 00
11101000 00
11101001 00
11101010 00
11101011 00
11101100 01
11101101 01
11101110 01
11101111 01
11110000 00
11110001 00
11110010 00
11110011 00
11110100 00
11110101 00
11110110 00
11110111 00
11111000 00
11111001 00
11111010 00
11111011 00
11111100 01
11111101 01
11111110 01
11111111 01
.e
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.
2 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
#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)
# exact Time was 0.00 sec, cost is c=10(0) in=23 out=13 tot=36
.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:
# exact Time was 0.01 sec, cost is c=10(0) in=23 out=13 tot=36
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
Profesor Leopoldo Silva Bijit 19-01-2010
| ( 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
c
d
a
f2
a<=c
d>a
Figura 2. Descomposición de f2.
Ahora los mapas de los subsistemas involucran a 4 variables, y pueden escribirse directamente:
00 01 11 10
00
01
11
10
1
1
1
1
0
1
1
1
0
0
1
0
0
0
1
1
15 11 7 3
14 10 6 2
13 9 5 1
12 8 4 0 c1c0
a1a0
a<=c
00 01 11 10
00
01
11
10
0
0
0
0
1
2 0
0
0
1
1
0
1
1
1
0
0
15 11 7 3
14 10 6 2
13 9 5 1
12 8 4 0 a1a0
d1d0
d>a
Figura 3. Mapas de los subsistemas de la descomposición de f2.
4 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
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
Profesor Leopoldo Silva Bijit 19-01-2010
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.
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.
a<d
a<=c
a>b
b>c
c>d
6 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
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.
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:
xor
Diseño Modular. 7
Profesor Leopoldo Silva Bijit 19-01-2010
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.
8 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
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.
Figura 11. Esquemático en base a LUTs de las funciones f1 y f2.
f2
f1 d
b
a
c
Diseño Modular. 9
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,
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.
10 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
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
Profesor Leopoldo Silva Bijit 19-01-2010
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.
12 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
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
Profesor Leopoldo Silva Bijit 19-01-2010
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.
14 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
Figura 20. Producto del nodo 3.
Se tiene para el nodo 2, la ecuación: n2= c0’a1a0.
Figura 21. Producto del nodo 2.
Se tiene para el nodo 1, la ecuación: n1= d0’a1c1’.
Figura 22. Producto del nodo 1.
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
Profesor Leopoldo Silva Bijit 19-01-2010
Figura 23. Producto del nodo 0.
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.
16 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
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
Profesor Leopoldo Silva Bijit 19-01-2010
Í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 20. PRODUCTO DEL NODO 3. .......................................................................................................... 14 FIGURA 21. PRODUCTO DEL NODO 2. .......................................................................................................... 14 FIGURA 22. PRODUCTO DEL NODO 1. .......................................................................................................... 14 FIGURA 23. PRODUCTO DEL NODO 0. .......................................................................................................... 15 FIGURA 24. PRODUCTO DE FUNCIÓN F1. ...................................................................................................... 15
18 Sistemas Digitales
Profesor Leopoldo Silva Bijit 19-01-2010
FIGURA 25. MAPEO TECNOLÓGICO DE LOS NODOS A UNA CPLD. ................................................................ 16