Diseño modular con Verilog. - Inicio · Departamento …lsb/elo211/clases/DisenoModular2.pdf · 1...

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


//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

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



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.



#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

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.



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.

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



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


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.

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

f2

f1 d

b

a

c

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 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



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

Diseño modular con Verilog. - Inicio · Departamento …lsb/elo211/clases/DisenoModular2.pdf · 1...

Documents

Transcript of Diseño modular con Verilog. - Inicio · Departamento …lsb/elo211/clases/DisenoModular2.pdf · 1...