· 1 vhdl’87 – subconjunto sintetizable* *para synospys vhdl compiler diseño automático de...

1

VHDL’87 VHDL’87 –– subconjunto sintetizable subconjunto sintetizable***para Synospys VHDL Compiler

Diseño Automático de SistemasDiseño Automático de Sistemas

José Manuel Mendías CuadrosJosé Manuel Mendías CuadrosDptoDpto. Arquitectura de Computadores y Automática. Arquitectura de Computadores y Automática

Universidad Complutense de MadridUniversidad Complutense de Madrid

2

diseño automático de sistemasdiseño automático de sistemas

introducciónintroducción

⌦ Muchas de las construcciones VHDL, aunque sean útiles para simulación y otrasetapas del ciclo de diseño, no son relevantes desde el punto de vista de la síntesis,por ello o bien no son soportadas, o bien sólo lo son parcialmente.

⌦ Desde el punto de vista de una herramienta de síntesis (en particular desde elVHDL Compiler), las construcciones VHDL pueden clasificarse en:Ø Soportadas: especifican cláramente una funcionalidad HW que debe sintetizarse.

Ø Ignoradas: pueden encontrarse en el código fuente VHDL, pero no se tienen en cuentadurante el proceso de síntesis.

Ø Prohibidas: no pueden aparecer en el código fuente VHDL, si lo hacen se aborta elproceso de síntesis.

3


unidades de diseñounidades de diseño

⌦ EntityØ El cuerpo de sentencias se ignora, tanto el declarativo como el ejecutivo.

Ø Los genéricos se soportan si son de tipo integer.

ü usar pares de funciones de codificación a integer y de decodificación al tipo deseado.

Ø Los valores iniciales de los puertos se ignoran.

⌦ ArchitectureØ Se permiten múltiples arquitecturas por entidad pero sólo se sintetiza una.

Ø Se prohibe la interacción mediante señales globales.

⌦ ConfigurationØ Se ignoran si especifican el nivel más alto de la jerarquía, en otro caso están prohibidas.

Ø Las configuraciones explícitas están prohibidas.

Ø El enlace se realiza mediante comandos específicos de la herramienta de síntesis.

⌦ Package y package bodyØ Soportados con restricciones según sus contenidos.

⌦ BibliotecasØ La existencia de bibliotecas y la compilación separada de unidades está soportada.

4


sentencias concurrentessentencias concurrentes

⌦ ProcessØ La lista de sensibilidad se ignora, pero para asegurar coherencia entre simulación y síntesis

debe seguirse las normas habituales de modelado en VHDL..

⌦ BlockØ Los bloques guardados y los bloques con puertos están prohibidos.

⌦ Otras sentencias concurrentesØ La llamada concurrente a procedimiento está soportada.

Ø La aserción concurrente es ignorada.

Ø Todos los tipos de asignación concurrente están soportados.

ü El modelo de retardo especificado en la asignación se ignora.

ü La asignación de formas de onda está prohibida.

Ø La instanciación de componentes está soportada.

Ø La generación está soportada.

5


sentencias secuencialessentencias secuenciales

⌦ Sentencias condicionalesØ Las sentencais if y case stán soportadas.

⌦ BuclesØ El bucle tipo for está soportado si el rango del índice es estático y el cuerpo no contiene

sentencias wait.Ø Los bucles de tipo while o sin esquema de repetición están soportado si el cuerpo

contiene alguna sentencia wait.

⌦ AsignaciónØ La asignación a variables está soportadaØ La asignación a señales está soportada.

ü El modelo de retardo especificado en una asignación de señal se ignora.ü La asignación de formas de onda está prohibida.

⌦ Sentencia waitØ Sólo está soportada bajo las siguientes formas (todas equivalentes)

ü wait until clock = VALUE;ü wait until clock’event and clock = VALUE;ü wait until not clock’stable and clock = VALUE;

Ø No pueden usarse en bucles for ni en subprogramas

⌦ Otras sentencias secuencialesØ Las aserciones secuenciales se ignoran.Ø La llamada secuencial a procedimiento está soportada.Ø Las sentencias next, exit, return y null están soportadas.

6


declaraciones (i): objetosdeclaraciones (i): objetos

⌦ Constantes.Ø Completamente soportadas.Ø Los genéricos se soportan si son de tipo entero.

⌦ Variables.Ø El tipo debe ser globalmente estático.Ø Los valores iniciales se ignoran.

⌦ Señales.Ø El tipo debe ser globalmente estático.Ø Los valores iniciales se ignoran.Ø Prohibidas de clases bus y register, y por consiguiente las especificaciones de

desconexión.Ø Se permiten las señales resueltas siempre y cuando la función de resolución especifique

lógica cableada o tri-estado.ü El cuerpo de las funciones de resolución es ignorado, por ello debe estar marcado con

la directiva resolution_method.Ø Los puertos con modos buffer y linkage se interpretan como out e inout,

respectivamente.

⌦ Ficheros.Ø Prohibidos.

⌦ ComponentesØ Deben tener siempre el mismo nombre que alguna entidad válida (la asociación dentro de

la herramienta se hace por nombre y no por configuración).

7


declaraciones (declaraciones (iiii): tipos y otros): tipos y otros

⌦ La declaración completa de tipos y subtipos está soportada con restricciones.⌦ Reales

Ø Las declaraciones de tipos reales se ignoran.Ø Su uso está prohibido, excepto como literales en atributos definidos por Synopsys.

⌦ EnterosØ No se soportan con precisión infinita, deben especificarse con un rango explícito.Ø Todo objeto de un tipo entero se representa mediante un vector de bits lo más pequeño

posible tal que pueda representar todos los valores posibles del rango especificado.Ø Si el rango especificado incluye números negativos, la representación usada será

complemento a 2, en otro caso binaria pura.Ø Los tipos predefinidos natural y positive están soportados.

⌦ EnumeradosØ Completamente soportados.Ø Todo objeto de un tipo enumerado se representa mediante un vector de bits lo más

pequeño posible tal que pueda representar todos los valores posibles del tipo.Ø Por defecto, cada uno de los literales del tipo se representa mediante la codificación en

binario puro de su posición dentro de la declaración. Esta codificación puede alterarseutilizando el atributo enum_encoding.

Ø Los tipos predefinidos character, boolean y bit están soportados.

⌦ FísicosØ Las declaraciones de tipos físicos se ignoran.Ø Su uso en especificaciones de retardo se ignoran, cualquier otro uso está prohibido.

8


declaraciones (declaraciones (iiiiii): tipos y otros): tipos y otros

⌦ VectoresØ Sólo se soprtan vectores monodimensionales de cualquier tipo soportado, por lo que

aunque estén prohibidos los multidimensionales, pueden utilizarse los vectores devectores.

Ø Sólo se soportan índices enteros.

Ø Se soporta la declaración y uso de vectores limitados y no limitados.

Ø Todos los atributos sobre vectores están soportatos.Ø Recordar que los tipos predefinidos string y bit_vector son vectores.

⌦ RegistrosØ Completamente soportados.

⌦ Punteros y ficherosØ Las declaraciones de tipo fichero o puntero se ignoran.

Ø Su uso está prohibido.

⌦ AliasØ Se ignoran.

⌦ AtributosØ La declaración está soportada y la especificación también siempre que no contenga all u

others.

Ø El uso de atributos declarados por el usuario está prohibido.

Ø Sólo está soportado el uso de algunos atributos predefinidos p definidos por Synopsys

9


subprogramassubprogramas

⌦ Sólo pueden declararse en paquetes o en la zona declarativa de las arquitecturas.

⌦ La sobrecarga de subprogramas (y de operadores) está soportada.

⌦ No pueden contener sentencias wait, por lo que pueden considerarse comoinstancias de circuitos combinacionales.

⌦ Se prohiben los valores por defecto de los parámetros

⌦ Se prohiben las asignaciones a índices o rebanadas de un parámetro de salidavectorial no restringido, a menos que el parámetro actual asociado sea unidentificador.

⌦ La recursividad está prohibida si no está acotada por un valor estático.

⌦ Las funciones de resolución se permiten únicamente cuando especifican lógicacableada o tri-estado

10


expresiones: operadores y literalesexpresiones: operadores y literales

⌦ OperadoresØ Están soportados los lógicos, relacionales, aditivos, signo aritmético, valor absoluto y

concatenación.

Ø Multiplicación, divisón y resto se soportan seún licencias según licencias. Si tales licenciasno están disponibles, el operando derecho debe ser una constante múltiplo de 2.

Ø Exponenciación solamente se soporta cuando ambos operandos son constantes y elderecho es múltiplo de 2.

⌦ LiteralesØ Los literales numéricos (con o sin base) están soportados.

Ø Los vectores, rangos o rebanadas nulos están prohibidos.

Ø Los literales físicos se ignoran.

Ø Los literales tipo cadena están soportados

Ø Los literales agregados sólo se permiten sobre vectores

11


expresiones: nombres y otrosexpresiones: nombres y otros

⌦ NombresØ Los identificadores simples están soportados.

Ø La selección de identificadores está prohibida a excepción de que aparezca en la sentenciause. Está prohibido puentear el ámbito de visibilidad de los identificadores.

Ø Los indexados y rebanados de identificadores están soportados con excepción de los quese hacen sobre parámetros de salida de tipo vectorial no restringido. Deben ser estáticos.

Ø Los identificadores atribuidos están soportados con algunas restricciones:ü Los atributos predefinidos base, left, right, high, low, range, reverse_range,

y length, están completamente soportados.

ü Los atributos predefinidos event y stable están soportados con restricciones.

ü Los atributos definidos por el usuario están prohibidos.

ü Los atributos definidos por Synopsys están completamente soportados.

⌦ Calificación y conversiónØ Completamente soportadas

12


implementaciónimplementación de asignaciones concurrentes (i) de asignaciones concurrentes (i)

⌦ Toda asignación de señal (o su proceso equivalente) se implementa como unbloque de lógica combinacional:Ø Con un único puerto de salida (que puede ser vectorial en modelos de nivel RT).

Ø Con tantos puertos de entrada como señales diferentes aparezcan en la expresión.

Ø Con una funcionalidad especificada por los operadores que forman la expresión.

LC

señal <= expresión;

operadoresseñales

+

a

b

+

c

d

d <= ( a + b ) + c

d <= ( a or b ) and c

a

bc

d

Una posible implementación de la sentencia ya que laimplementación definitiva siempre la decide la herramienta

13


implementaciónimplementación de asignaciones concurrentes ( de asignaciones concurrentes (iiii))

⌦ Toda asignación condicional de señal (o su proceso equivalente) se implementacomo un bloque de lógica combinacional:Ø Con un único puerto de salida (que puede ser vectorial en modelos de nivel RT).

Ø Con tantos puertos de entrada como señales diferentes aparezcan en el lado derecho de laasignación (independientemente de la expresión en la que ocurran).

Ø Con un comportamiento que se corresponde con el de un multiplexor 2 a 1 cuyas 3entradas están conectadas a las salidas de 3 bloques combinacionales. La funcionalidadde dichos bloques queda especificada por los operadores que forman cada una de las 3expresiones de la sentencia.

señal <= expresión when expresión_booleana else expresión;

1

0

LC

LC

LC

d <= (a or b) when (c = ‘0’) else (a and b);

1

0

d

a

b

c

14


implementaciónimplementación de asignaciones concurrentes ( de asignaciones concurrentes (iiiiii))

⌦ La asignación condicional del valor explícito ‘Z’ (uno de los valores del tipostd_logic) especifica la capacidad tri-estado del puerto de salida de la lógicacombinacional especificada por el resto de la sentencia.

d <= (a or b) when (c = ‘0’) else ‘Z’;d <= ‘Z’ when (c =‘0’) else (a and b);

d

a

b

c

a

b

c

señal <= expresión when expresión_booleana else (others=>‘Z’);

LC

LC

15


implementaciónimplementación de asignaciones concurrentes ( de asignaciones concurrentes (iviv))

señal <= expresión when expresión_booleana else expresión when expresión_booleana else expresión;

1

0

LC

LC

1

0

LC

LC

LC

⌦ Una colección de asignaciones condicionales anidadas (o su procesoequivalente) se implementada como lógica combinacional en cascada que estableceprioridades explícitas entre varios cálculos.

lógica más prioritaria

16


implementaciónimplementación de asignaciones concurrentes (v) de asignaciones concurrentes (v)

with expresión select señal <= expresión when valor, ... expresión when valor;

n-1

0

LC

LC

LC

LC

⌦ Toda asignación selectiva de señal (o su proceso equivalente) se impelementacomo un bloque de lógica combinacional:Ø Con un único puerto de salida (que puede ser vectorial en modelos de nivel RT).

Ø Con tantos puertos de entrada como señales diferentes aparezcan en el lado derecho de laasignación (independientemente de la expresión en la que ocurran).

Ø Con un comportamiento que se corresponde con el de un multiplexor 2n a 1 cuyas 2n

entradas están conectadas a las salidas de n+1 bloques combinacionales. La funcionalidadde dichos bloques queda especificada por los operadores que forman cada una de las n+1expresiones de la sentencia. Siendo n el número de bits con los que se codifica el resultadode la expresión selecionada.

with c select d <= (a or b) when “00” (a and b) when “11” | “10”, ‘1’ when others;

3

0

2

1

dVcc

c2

a

b

17


implementaciónimplementación de expresiones (i) de expresiones (i)

⌦ Las expresiones son el mecanismo fundamental para especificar la funcionalidadcombinacional de un circuito.

⌦ Las expresiones VHDL, desde el punto de vista de síntesis, pueden clasificarse en:Ø Expresiones computables: aquellas cuyo resultado puede ser determinado en tiempo de

análisis, por tanto tienen un valor estático.

ü No requieren HW que las calcule, se implementan como conexiones a VCC y/o GND.

Ø Expresiones no computables: aquellas cuyo resultado no puede ser determinado entiempo de análisis, por tanto tienen un valor dinámico.

ü Se implementan mediante HW combinacional que las calcula.

⌦ Son expresiones no computables aquellas que contengan:Ø Señales o puertos.

Ø Variables que hayan sido anteriormente asignadas por una expresión no computable.

Ø Variables que hayan sido anteriormente asignadas (aunque sea por expresionescomputables) en función del valor de una condición no computable.

18


implementación implementación de expresiones (de expresiones (iiii))architecture ... of ... is signal s : std_logic; function mux( a, b, c : std_logic ) return std_logic is begin if (c = ‘1’) then return a; else return b; end if; end; procedure comp( a : std_logic; b : out std_logic ) is begin b := not a; end; ...begin process( s ) variable v0, v1, v2 : std_logic; variable vInt : integer; subtype miVector is std_logic_vector(0 to 3); variable vVector : miVector; begin v0 := ‘1’; v1 := v0; v2 := not v1; for i in 0 to 3 loop vInt := i; end loop; vVector := miVector’(v1, v2, ‘0’, ‘0’); v1 := mux( v0, v1, v2 ); comp( v1, v2 ); v0 := s and ‘0’; v1 := mux( s, ‘1’, ‘0’ ); v1 := mux( ‘1’, ‘1’, s ); if (s = ‘1’) then v2 := ‘0’; else v2 := 1; end if; v1 := s; v2 := v1 or ‘0’; end process; ...end ...;

computable, v0 vale ‘1’



computable, vInt vale 3

computable, vVector vale “1000”






no computable, v2 depende de s



19


implementación implementación de expresiones (de expresiones (iiiiii))

⌦ Las expresiones simples (formadas un único operador) especifican una conductaprimitiva sin estructura interna aparente.

⌦ Cuando se especifica una conducta compleja se necesita utilizar una expresióncompuesta (formada por varios operadores) o varias expresiones que se comunicana través de señales (o variables), por ello se está especificando:Ø La propia conducta a diseñar.

Ø Una ordenación de los cálculos que se traduce en una estructura inicial sobre la que laherramienta comenzará a optimizar.

⌦ Dicha estructura inicial es determinante (sobre todo a nivel RT) a la hora de obtenerbuenos resultados, ya que puede desde facilitar la búsqueda del diseño ideal hastaocultarlo.

q <= (((b+c)+a)+(d+e))+f;

+

+

+

+ +

b

c a

d

e

f

q

q <= b + c + a + d + e + f;

+

+

+

+

+

b

c

a d

e f

q

+

++

++

b

c

a

e

f

d q

20


implementación implementación de expresiones (de expresiones (iviv))

d <= (a - b) when (a > b) else (b - a);

a b

> - -

1 0

d

d <= left - right;c <= (a > b);left <= a when c else b;right <= b when c else a;

a b

>

-

d

1 0 1 0

21


cualquier sentencia if o caseincompeltamente especificada

implica la necesidad de almacenarlos valores no modificados

implementaciónimplementación de procesos (i) de procesos (i)

⌦ Un proceso especifica HW combinacional si todas las señales o variables escritasdentro del mismo se asignan al menos una vez bajo cualquier condición de ejecución.

⌦ Por el contrario un proceso especifica HW secuencial si las señales o variables escritasdentro del mismo no se asignan por defecto, sólo bajo ciertas condiciones de ejecuciónØ Típicamente tras la detección de un nivel o un evento en cierta señal

⌦ Un proceso también especifica HW secuencial si contiene al menos una sentencia wait.

process( a, b, c, d )begin if (a = ‘1’) then e <= c; elsif (b = ‘1’) then e <= d; else e <= ‘0’; end if;end process;

e

a

c

bd

process( a, b, c, d )begin if (a = ‘1’) then e <= c; elsif (b = ‘1’ ) then e <= d; end if;end process;

a

b

GQ De

a

c

bd

El tipo de expresiones utilizadas (denivel o de flanco) determinan el tipo

de HW secuencial

22


implementaciónimplementación de procesos ( de procesos (iiii): ejemplos): ejemplos

process( gate, d )begin if (gate = ‘1’) then q <= d; end if;end process;

process( set, rst )begin if (set = ’1’) then q <= ’1’; elsif (rst = ’1’) then q <= ’0’; end if;end process;

Latch tipo SR

Latch tipo D

process( gate, set, rst, d )begin if (rst = ‘1’) then q <= ‘0’; elsif (gate = ‘1’) then q <= d; end if;end process;

Latch tipo D con reset asíncrono

process( gate, set, rst, d )begin if (set = ‘1’) then q <= ‘1’; elsif (rst = ‘1’) then q <= ‘0’; elsif (gate = ‘1’) then q <= d; end if;end process;

Latch tipo D con set y reset asíncrono

Latch tipo D master-slave

master: process( clk, d )begin if (clk = ‘1’) then q <= d; end if;end process;slave: process( clk, d )begin if (clk = ‘0’) then q <= d; end if;end process;

23


processbegin wait until (clk’event and clk = ‘1’); q <= d;end process;

implementaciónimplementación de procesos ( de procesos (iiiiii): ejemplos): ejemplos

process( clk )begin if (clk’event and clk = ‘1’) then q <= d; end if;end process;

Flip-flop tipo D

process( clk, rst )begin if (rst =‘1’) then q <= ‘0’; elsif (clk’event and clk = ‘1’) then q <= d; end if;end process;

Flip-flop tipo D con reset asíncrono

process( clk, rst )begin if (clk’event and clk = ‘1’) then if (rst = ‘1’) then q <= ‘0’; else q <= d; end if; end if;end process;

Flip-flop tipo D con reset síncrono

process variable jk : std_logic_vector (1 downto 0);begin if (clk’event and clk = ’1’) then jk := (j & k); case jk is when ”01” => q <= ’0’; when ”10” => q <= ’1’; when ”11” => q <= not( q ); when ”00” => q <= q; when others => q <= ’X’; end case; end if;end process;

Flip-flop tipo JK

process( clk )begin if (clk’event and clk = ‘1’) then q <= not( q ); end if;end process;

Flip-flop tipo T

24


implementaciónimplementación de procesos ( de procesos (iviv): limitaciones): limitaciones

⌦ Al especificar elementos de memoria disparados por flanco existen algunas restricciones:Ø Sólo existen 2 tipos de especificaciones de flanco válidas:

ü clk’event and clk=‘1’ flanco de subida

ü clk’event and clk=‘0’ flanco de bajada

Ø Una especificación de flanco no puede utilizarse como operando.

ü aunque su presencia en VHDL pueda evaluarse, un evento HW es el punto de división entredos valores estables diferentes; por tanto, al no ser un valor en sí mismo, no puede utilizarsecomo argumento en un cálculo.

Ø Una sentencia if que tenga por condición una especificación de flanco no puede tener rama else.

ü en caso contrario la acción especificada debería realizarse en todo momento menos en elpreciso instante en el que el reloj cambia.

Ø En sentencias if-then-elsif la especificación de flanco sólo podrá ser la condición del último if (que nopodrá tener rama else).

Ø En un proceso solo puede existir una única especificación de flanco.

ü en caso contrario se estaría especificando HW secuencial sensible a varios relojes.

Ø Un variable asignada en el cuerpo de una sentencia if-then cuya condición sea una especificación deflanco, no puede ser usada fuera del mismo.

ü en caso contrario existiría una inconsistencia entre el comportamiento del circuito que se estáespecificado y el comportamiento que se simularía.

25


implementaciónimplementación de procesos (v): limitaciones de procesos (v): limitaciones

process( rst, clk )begin if (clk’event and clk=‘1’ and rst=‘1’) then ... end if;end process;

process( clk )begin if not(clk’event and clk=‘1’) then ... end if;end process;

process( clk )begin if ... then ... elsif (clk’event and clk=‘1’) then ... else ... end if;end process;

process( clk )begin if (clk’event and clk=‘1’) then ... else ... end if;end process;

process( clk1, clk2 )begin if (clk1’event and clk1=‘1’) then ... end if; if (clk2’event and clk2=‘1’) then ... end if;end process;

process( clk ) variable aux : ...;begin if (clk’event and clk=‘1’) then ... aux := ...; z <= aux1; end if; z <= aux1;end process;

una especificación de flanco no puedeutilizarse como operando

en un proceso sólo puede existiruna especificación de flanco

un if con especificación de flanco no puede tener rama else

asignación válida

asignación no válida

26


implementaciónimplementación de procesos (vi): variables de procesos (vi): variables vs vs. señales. señales

⌦ Las señales deben usarse:Ø Para almacenar el estado de los procesos ‘secuenciales’.Ø Como medio de comunicación entre procesos u otras sentencias concurrentes.

ü El orden de asignación concurrente de señales no importa.ü El orden de asignación secuencial de señales sí importa: si bajo unas condiciones de

ejecución un proceso asigna varias veces una misma señal sólo se diseñará lógicapara implementar la última asignación.� Esto es útil en procesos ‘combinacionales’ , que pueden tener a su comienzo una asignación

incondicional del valor por defecto de todas las señales y posteriormente asignacionesselectivas.

⌦ Las variables deben usarseØ Para simplificar las expresiones contenidas en los procesos ‘combinacionales’. Reducir o

preferiblemente eliminar su uso en procesos ‘secuenciales’.ü El orden de asignación de variables puede importar si se asignan o no antes de ser

usadas y si el proceso es ‘combinacional’ o ‘secuencial’.

architecture ... ...begin d <= a and b; d <= a or b; ...end ...;

architecture ... ...begin process( a, b ) d <= a and b; d <= a or b; end process ...end ...;

d

a

bd

a

b

27


process( clk, input ) variable a, b : ...;begin if clk = ‘1’ then b := a; a := input; output <= b; end if;end process;

implementaciónimplementación de procesos ( de procesos (viivii): variables): variables vs vs. señales. señales

process( input ) variable a : ...;begin output <= a; a := input + 1;end;

process( input ) variable a : ...;begin a := input + 1; output <= a;end;

Al ser ambos procesos ‘combinacionales’, actualizan variables y señales en cualquiera de susejecuciones, como en el modelo VHDL las variables conservan valores entre llamadas la

implementación debe ser en cualquier caso un incrementador. Esto provoca inconsistencias entresimulación y síntesis y la herramienta avisa de que se lee la variable antes de escribirla

process( clk, input ) variable a, b : ...;begin if clk = ‘1’ then a := input; b := a; output <= b; end if;end process;

QD

G

input output

clk

QD

G

QD

G

input output

clk

a b

1

input

+ output

En procesos ‘secuenciales’ el orden de lasasignaciones de variables determina el

número de elementos de memoria

28


⌦ Por defecto, cada ocurrencia de un operador da lugar a un bloque de lógica(recurso) que la implementa.

⌦ Cuando un único bloque de lógica puede implementar varias ocurrencias de unoperador se dice que dichas ocurrencias comparten el recurso.Ø Esto es posible si la ejecución de dichas ocurrencias es mutuamente exclusiva, es decir,

que no existe ninguna condición de ejecución bajo la cual se necesite calcularsimultáneamente más de uno de los operadores que comparten el recurso.

⌦ Para que dos operadores compartan un recurso debe cumplirse que:Ø ocurran dentro del mismo proceso.

Ø sean mutuamente exclusivos.

Ø sean compatibles.

Ø que la implementación del reuso no incurra

en una realimentación combinacional.

implementaciónimplementación de procesos ( de procesos (viiiviii):): reuso reuso

process( cond, a, b )begin if (a > b ) then d <= a - b; else d <= b - a; end if;end process;

a b

>

-

d

1 0 1 0

29


implementaciónimplementación de procesos ( de procesos (ixix):): reuso reuso

process(a,b,c,d,e,f,g,h,i,j,k,l,m,n,c1,c2)begin z1 <= a + b; if c1 then z2 <= c + d; else z2 <= e + f; if c2 then z3 <= g + h; else z3 <= i + j; end if; end if; if not c1 then z4 <= k + l; else z4 <= m + n; end if;end process;

⌦ Dos ocurrencias del mismo operador son siempre compatibles. Dos ocurrencias de diferentesoperadores serán compatibles si ambas pertenecen a uno de los siguientes conjuntosØ { +, - }

Ø { >, >=, <, <= }

VHDL Compiler considera que todas lascondiciones no tienen relación

a + b

nononononono

c + d

no

sisisinono

a + bc + de + fg + hi + jk + lm + n

e + f

nosi

nononono

g + h

nosino

sinono

i + j

nosinosi

nono

k + l

nonononono

si

m + n

nononononosi

30


implementaciónimplementación de procesos (x): de procesos (x): reuso reuso

a b

+ +

1 0

z

++

c f d e

c1

t1 t2

a f

+

1 0 1 0

b

t2

c1c1

1 0

+

1 0

c e

c1c1

t1

d

1 0

z

c1

process(a,b,c,d,e,f,c1) variable t1, t2 : ...;begin if c1 then t1 := a + b; z <= t1 + c; else t2 := d + e; z <= f + t2; end if;end process;

Lazo combinacional:reuso no válido

31


implementaciónimplementación de de subprogramas subprogramas

⌦ Los subprogramas siempre se implementa como un bloque de lógica combinacionalØ Pro ello, los procedimientos no pueden conterner sentencias wait.

process( gate, d ) begin if (gate = ‘1’) then q <= d; end if;end process;

function fun( d, gate : bit ) return bit is variable q: bit;begin if (gate = ‘1’) then q := d; end if; return q;end;...q <= fun( d, gate );...

QD

G

d q

gate

Las variables de subprogramas son dinámicas,por lo que no retienen valores entre llamadas

Las funciones siempre deben devolver un valor

Cuando una variable se crea se inicializa pordefecto al primer valor de su declaración de tipo,

en el caso de bit, este valor es ‘0’ y seconservará hasta que se asigne otro

d0011

gate0101

return0001

gate

dq

32


paquetes estándar (i): paquetes estándar (i): stdstd__logiclogic_1164_1164

⌦ El paquete std_logic_1164 define 2 tipos atómicos multivaluados (uno resuelto yotro no) y 2 tipos vectoriales asociados:

⌦ El significado de cada uno de los 9 valores es:Ø ‘0’ y‘1’: valores lógicos fuertes

Ø ‘L’ y ‘H’: valores lógicos débiles

Ø ‘Z’: alta impedancia

Ø ‘X’: valor fuerte desconocido

Ø ‘W’: valor débil desconocido

Ø ‘U’: no inicializado

Ø ‘-’: indiferencia (don’t care)

⌦ Dentro del paquete se definen también una colección de operadores y funcioneslógicas sobre dichos tipos (tanto atómicos como vectoriales).Ø and, nand, or, nor, xor, xnor, not

⌦ Este paquete define un estándar para la especificación del interconexionado entremodelos VHDL (está soportado por todas las herramientas de síntesis).Ø Los puertos de un diseño deberán ser siempre de estos tipos.

Ø También es recomendable que los objetos internos se declaren de estos tipos.

type std_ulogic is ( 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-' );type std_ulogic_vector is array ( natural range <> ) of std_ulogic;subtype std_logic is resolved std_ulogic;type std_logic_vector is array ( natural range <> ) of std_logic;

33


paquetes estándar (paquetes estándar (iiii): ): stdstd__logiclogic_1164_1164

⌦ Los valores lógicos fuertes, ‘0’ y ‘1’ especifican respectivamente conexiones a tierra o a alimentación

⌦ Los valores lógicos débiles, ‘L’ y ‘H’ especifican respectivamente conexiones a tierra o a alimentación.

⌦ La utilización del valor metalógico ‘Z’ en una asignación, especifica un buffer triestado habilitado por lamisma condición bajo la cual se realiza tal asignación. En cualquier otro caso, se interpreta como el restode los valores metalógicos.

⌦ La utilización del valor metalógico ‘-’ en una asignación, especifica una indiferencia en el valor efectivoque debe asignarse. En cualquier otro caso, se interpreta como el resto de los valores metalógicos.

⌦ Los valores metalógicos ‘U’, ‘W’, ‘X’ y en ocasiones ‘-’ y ‘Z’, carecen de sentido en síntesis.Ø El resultado de una comparación de igualdad con un valor metalógico explícito es siempre falsa desde el punto de

vista de síntesis, luego no requiere HW.

Ø El resultado de una comparación de desigualdad con un valor metalógico explícito es siempre cierta desde el puntode vista de síntesis, luego no requiere HW.

Ø Cuando se utililiza un valor metalógico explícito en una selección se considera, desde el punto de vista de síntesis,que la alternativa especificada no se ejecutará nunca, luego no requiere HW.

Ø Está prohibida la utilización de un valor metalógico explícito como operando de un operador aritmético o lógico.

with s select z <= ‘0’ when “0000” ‘1’ when “0001” x1 when “0---” x2 when others;

with s select z <= ‘0’ when “0000” ‘1’ when “0001” x2 when others;

z <= ‘0’ when s = “00-1” else ‘1’; z <= ‘1’;

z <= ‘0’ when s /= “00-1” else ‘1’; z <= ‘0’;

z <= ‘0’ when s = “0011” else ‘-’; z <= ‘0’;

Interpretación de los valores del tipo

34


paquetes estándar (paquetes estándar (iiiiii): ): stdstd__logiclogic__aritharith

⌦ El paquete std_logic_arith define 2 tipos de datos vectoriales que, basados en elmultivaluado std_logic, son interpretables como valores numéricos codificados. La longituddel vector determina el rango de valores representables por un objeto de tales tipos.

⌦ El tipo UNSIGNED especifica un número natural representado en binario puro (estando elbit más significativo colocado a la izquierda).

Ø El número 8 puede representarse como UNSIGNED’(”1000”) o como UNSIGNED’(”001000”)

⌦ El tipo SIGNED especifica un número entero representado en complemento a 2 (estando elbit de signo colocado a la izquierda).

Ø El número +5 puede representarse como SIGNED’(”0101”) o como SIGNED’(”00101”)

Ø El número -5 puede representarse como SIGNED’(”1011”) o como SIGNED’(”1111011”)

⌦ Dentro del paquete existen:Ø Funciones de conversión sobrecargadas entre los tipos INTEGER, UNSIGNED, SIGNED,

STD_ULOGIC y STD_LOGIC_VECTOR.

Ø Operadores aritméticos para los tipos INTEGER, UNSIGNED, SIGNED y STD_ULOGIC.

Ø Operadores relacionales para los tipos INTEGER, UNSIGNED y SIGNED.

Ø Funciones de desplazamiento aritmético para los tipos SIGNED y UNSIGNED.

type UNSIGNED is array (natural range <>) of std_logic;

type SIGNED is array (natural range <>) of std_logic;

35


paquetes estándar (paquetes estándar (iviv): ): stdstd__logiclogic__aritharith

subtype SMALL_INT is INTEGER range 0 to 1;

function CONV_UNSIGNED(ARG: INTEGER; SIZE: INTEGER) return UNSIGNED;function CONV_UNSIGNED(ARG: UNSIGNED; SIZE: INTEGER) return UNSIGNED;function CONV_UNSIGNED(ARG: SIGNED; SIZE: INTEGER) return UNSIGNED;function CONV_UNSIGNED(ARG: STD_ULOGIC; SIZE: INTEGER) return UNSIGNED;

function CONV_SIGNED(ARG: INTEGER; SIZE: INTEGER) return SIGNED;function CONV_SIGNED(ARG: UNSIGNED; SIZE: INTEGER) return SIGNED;function CONV_SIGNED(ARG: SIGNED; SIZE: INTEGER) return SIGNED;function CONV_SIGNED(ARG: STD_ULOGIC; SIZE: INTEGER) return SIGNED;

function CONV_STD_LOGIC_VECTOR(ARG: INTEGER; SIZE: INTEGER) return STD_LOGIC_VECTOR;function CONV_STD_LOGIC_VECTOR(ARG: UNSIGNED; SIZE: INTEGER) return STD_LOGIC_VECTOR;function CONV_STD_LOGIC_VECTOR(ARG: SIGNED; SIZE: INTEGER) return STD_LOGIC_VECTOR;function CONV_STD_LOGIC_VECTOR(ARG: STD_ULOGIC; SIZE: INTEGER) return STD_LOGIC_VECTOR;

function CONV_INTEGER(ARG: INTEGER) return INTEGER;function CONV_INTEGER(ARG: UNSIGNED) return INTEGER;function CONV_INTEGER(ARG: SIGNED) return INTEGER;function CONV_INTEGER(ARG: STD_ULOGIC) return SMALL_INT;

Perfiles de las funciones de conversión

VHDL define que cualquier entero debe estar comprendido entre -2147483647 y 2147483647, un rango representable con un UNSIGNED de 31 bits o un SIGNED de 32 bits

convierten el entero a una reprentacióncon una anchura dada: si el número de bits

requeridos por el valor a convertir fuera menorque el especificado, la representación se

extiende adecuadamente; si por el contrariofuera mayor, se trunca por la izquierda.

36


paquetes estándar (v): paquetes estándar (v): stdstd__logiclogic__aritharith

function ”+”(L: UNSIGNED; R: UNSIGNED) return UNSIGNED;function ”+”(L: SIGNED; R: SIGNED) return SIGNED;function ”+”(L: UNSIGNED; R: SIGNED) return SIGNED;function ”+”(L: SIGNED; R: UNSIGNED) return SIGNED;function ”+”(L: UNSIGNED; R: INTEGER) return UNSIGNED;function ”+”(L: INTEGER; R: UNSIGNED) return UNSIGNED;function ”+”(L: SIGNED; R: INTEGER) return SIGNED;function ”+”(L: INTEGER; R: SIGNED) return SIGNED;function ”+”(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED;function ”+”(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED;function ”+”(L: SIGNED; R: STD_ULOGIC) return SIGNED;function ”+”(L: STD_ULOGIC; R: SIGNED) return SIGNED;function ”+”(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;function ”+”(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR;function ”+”(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR;function ”+”(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;function ”+”(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR;function ”+”(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR;function ”+”(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR;function ”+”(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR;function ”+”(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR;function ”+”(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR;function ”+”(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR;function ”+”(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR;

Perfiles de las funciones aritméticas

Cuando en la función existeun único argumento de tipoUNSIGNED o SIGNED, el

valor devuelto tiene lamisma anchura que dicho

argumento.

idén

ticos

par

a la

res

ta

Cuando los dos argumentos de lafunción son de tipo UNSIGNED o

SIGNED, la anchura del valordevuelto es la mayor de la lasanchuras de los argumentos.

Cuando se suma o resta unUNSIGNED y un SIGNED que es dela misma anchura o menor, el valordevuelto es un bit más ancho que el

argumento de tipo UNSIGNED

37


paquetes estándar (vi): paquetes estándar (vi): stdstd__logiclogic__aritharith

Perfiles de las funciones aritméticas (cont.)function ”*”(L: UNSIGNED; R: UNSIGNED) return UNSIGNED;function ”*”(L: SIGNED; R: SIGNED) return SIGNED;function ”*”(L: SIGNED; R: UNSIGNED) return SIGNED;function ”*”(L: UNSIGNED; R: SIGNED) return SIGNED;

function "*"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;function "*"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR;function "*"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;function "*"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR;

function ”+”(L: UNSIGNED) return UNSIGNED;function ”+”(L: SIGNED) return SIGNED;function ”-”(L: SIGNED) return SIGNED;function ”ABS”(L: SIGNED) return SIGNED;

function "+"(L: UNSIGNED) return STD_LOGIC_VECTOR;function "+"(L: SIGNED) return STD_LOGIC_VECTOR;function "-"(L: SIGNED) return STD_LOGIC_VECTOR;function "ABS"(L: SIGNED) return STD_LOGIC_VECTOR;

38


paquetes estándar (paquetes estándar (viivii):): stdstd__logiclogic__aritharith

Perfiles de las funciones relacionales

idén

ticos

par

a <

=, >

, >=

, =, /

=

function "<"(L: UNSIGNED; R: UNSIGNED) return BOOLEAN;function "<"(L: SIGNED; R: SIGNED) return BOOLEAN;function "<"(L: UNSIGNED; R: SIGNED) return BOOLEAN;function "<"(L: SIGNED; R: UNSIGNED) return BOOLEAN;function "<"(L: UNSIGNED; R: INTEGER) return BOOLEAN;function "<"(L: INTEGER; R: UNSIGNED) return BOOLEAN;function "<"(L: SIGNED; R: INTEGER) return BOOLEAN;function "<"(L: INTEGER; R: SIGNED) return BOOLEAN;

estas funciones comparan el valornumérico de los argumentos y no

la particular configuraciónconfiguración de bits

arg1

“000”“00”

“100”“000”“00”

“100”

arg2

“000”“000”

“0100”“000”“000”

“0100”

op

===<<<

unsigned

truetruetruefalsefalsefalse

signed

truetruefalsefalsefalsetrue

std_logic_vector

truefalsefalsefalsetruefalse

function SHL(ARG: UNSIGNED;COUNT: UNSIGNED) return UNSIGNED;function SHL(ARG: SIGNED;COUNT: UNSIGNED) return SIGNED;function SHR(ARG: UNSIGNED;COUNT: UNSIGNED) return UNSIGNED;function SHR(ARG: SIGNED;COUNT: UNSIGNED) return SIGNED

Perfiles de las funciones de desplazamiento

39


paquetes estándar (paquetes estándar (viiiviii):): stdstd__logiclogic__aritharith

⌦ El uso de las funciones del paquete std_logic_arith, requiere que los argumentosvectoriales sean de tipo signed o unsigned. Si se desea usarlas con argumentos detipo std_logic_vector, es necesario convertir explícitamente tales argumentos a unode dichos tipos (para indicar la representación de los datos).Ø El paquete std_logic_arith, deberá usarse en aquellas especificaciones que manipulen

tanto datos con signo como sin signo.

⌦ El paquete std_logic_unsigned define una nueva colección de funciones quepermite la manipulación directa de objetos de tipo std_logic_vector, interpretándolossiempre como valores sin signo.Ø Deberá usarse en aquellas especificaciones que únicamente manipulen datos sin signo.

⌦ El paquete std_logic_unsigned define una nueva colección de funciones quepermite la manipulación directa de objetos de tipo std_logic_vector, interpretándolossiempre como valores sin signo.Ø Deberá usarse en aquellas especificaciones que únicamente manipulen datos con signo.

⌦ Ambos paquetes convierten adecuadente los argumentos y hacen llamada a lafunción de std_logic_arith necesaria.

40


paquetes estándar (paquetes estándar (ixix): ): stdstd__logiclogic__unsignedunsigned

function CONV_INTEGER(ARG: STD_LOGIC_VECTOR) return INTEGER;function "+"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;function "+"(L: STD_LOGIC_VECTOR; R: INTEGER) return STD_LOGIC_VECTOR;function "+"(L: INTEGER; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;function "+"(L: STD_LOGIC_VECTOR; R: STD_LOGIC) return STD_LOGIC_VECTOR;function "+"(L: STD_LOGIC; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;...function "-"(L: STD_LOGIC; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;function "+"(L: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;function "*"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;...function "<"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN;function "<"(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN;function "<"(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN;...function SHL(ARG:STD_LOGIC_VECTOR; COUNT: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;function SHR(ARG:STD_LOGIC_VECTOR; COUNT: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;

Perfiles de las funciones del paquete std_logic_unsigned

41


paquetes estándar (x): paquetes estándar (x): stdstd__logiclogic__signedsigned

function CONV_INTEGER(ARG: STD_LOGIC_VECTOR) return INTEGER;function "+"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;function "+"(L: STD_LOGIC_VECTOR; R: INTEGER) return STD_LOGIC_VECTOR;function "+"(L: INTEGER; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;function "+"(L: STD_LOGIC_VECTOR; R: STD_LOGIC) return STD_LOGIC_VECTOR;function "+"(L: STD_LOGIC; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;...function "+"(L: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;function "-"(L: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;function "ABS"(L: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;function "*"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;...function "<"(L: STD_LOGIC_VECTOR; R: STD_LOGIC_VECTOR) return BOOLEAN;function "<"(L: STD_LOGIC_VECTOR; R: INTEGER) return BOOLEAN;function "<"(L: INTEGER; R: STD_LOGIC_VECTOR) return BOOLEAN;...

function SHL(ARG:STD_LOGIC_VECTOR;COUNT: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR; function SHR(ARG:STD_LOGIC_VECTOR;COUNT: STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR;

Perfiles de las funciones del paquete std_logic_signed

42


especificación deespecificación de HW HW usando usando VHDL VHDL: método: método

⌦ Pensar siempre en HW síncrono de nivel RT (las herramientas que utilizaremoscomienzan desde este nivel de abstracción).Ø No comenzar a codificar hasta tener el diagrama de bloques a nivel RT (módulos

combinacionales y registros).

ü El uso de VHDL no evita el diseño manual de la estructura RT, lo que evita es el diseñológico de los bloques combinacionales y la proyección tecnológica.

Ø Cada bloque RT habitualmente deberá codificarse con una sentencia concurrente.

Ø Se permiten especificaciones más abstractas, pero para que puedan obtenerse solucionesválidas es necesaria una codificación muy cuidadosa.

Ø Nunca mezclar en un mismo diseño diferentes estilos de temporización:

ü No utilizar más de un reloj por diseño.

ü No mezclar diseños con temporización a nivel con temporización a flanco.

ü Diseñar a mano los bloques asíncronos.

⌦ El núcleo fundamental de la lógica a sintetizar se especificará mediante expresiones.

⌦ El resto de construcciones del lenguaje se utilizarán para estructurar el diseño y paraespecificar su temporización.

43


estilos de especificación (i)estilos de especificación (i)

⌦ Un circuito diseñado a nivel lógico se caracteriza por 3 aspectos:Ø La función que realiza.

Ø La estructura interna que tiene.

Ø Las componentes de biblioteca que utiliza.

⌦ Para especificar con un mayor o menor nivel de detalle el circuito que se desea que laherramienta de síntesis obtenga, existen 3 estilos de uso del VHDL diferentes:Ø El que permite la inferencia de una estructura: se especifica únicamente el comportamiento del

circuito del modo más abstracto posible dando libertad a la herramienta para que elija la estructuray componentes más adecuadas bajo ciertas condiciones de funcionamiento.

Ø El que implica cierta estructura: se especifica tanto el comportamiento del circuito como unaestructura global del mismo en base al conocimiento que tiene el diseñador de las condiciones defuncionamiento del circuito. La herramienta seleccionará las componentes del circuito

Ø Que instancia ciertas componentes: se describe todo: función, estructura y componentes. Laherramienta realiza chequeos.

⌦ Los dos primeros estilos son independientes de tecnología, el tercero no.

⌦ Deberá utilizarse preferiblemente el primer estilo, el segundo se reserva para pocasocasiones. El tercero no es recomendable (es una captura de esquemas textual).

⌦ Es también muy común que una descripción no siga un estilo puro y utilice:Ø inferencia: para especificar las partes no críticas del circuito

Ø implicación: para especificar las partes críticas del circuito.

Ø instanciación: para especificar elementos cruciales o que no puedan ser diseñados (asíncronos)

44


process( estado, cond ) begin if cond then case estado is when ... => output <= ...; ... end case; else case estado is when ... => output <= ...; ... end case;end process;

process( estado, cond ) begin case estado is when ... => if cond then output <= ...; else output <= ...; end if; when ... => if cond then output <= ...; else output <= ...; end if; ... end case;end process;

estilos de especificación (estilos de especificación (iiii): ejemplos): ejemplos

LC1

0

ouputinput

estado cond

LCn-1

0

ouputinput

cond estado

si el diseñador conoce que la señal cond llega retrasada respecto al resto, estees una especificación inadecuada de la que será dificil obtener un circuito rápido

modificando laanidación puede

solventarse elproblema desdela especificacion

45


process( input ) begin ... output1 <= ...;end process;

process( input ) begin ... output2 <= ...;end process;

estilos de especificación (estilos de especificación (iiiiii): ejemplos): ejemplos

LC

LC

LC

LC

LC

LC

LC

LC

LC

oupu

t

input

LC

LC

LC

LC

LC

LC

LC

LC

LC

LC

input

input

oupu

t2ou

put1

process( input ) begin ... output <= ...;end process;

si el diseñador conoce que la señaloutput una alta conectividad, puedeevitar los altos retardos que induceduplicando explícitamente la lógica

46


especificación de especificación de HW combinacionalHW combinacional

⌦ La lógica combinacional puede ser especificada mediante:Ø Asignaciones concurrentes a señal.

Ø Procesos sin sentencias wait tales que:

ü Todas las señales o variables escritas dentro del proceso sean asignadas al menosuna vez en toda activación del mismo.� Si en el modelo existe un camino lógico tal que una señal o variable no se asigna, quiere decir

que el valor del objeto debe ser retenido y, por tanto, que debe existir un elemento secuencialque lo memorice.

ü Para asegurar la coherencia entre simulación y síntesis, la lista de sensibilidad debeser completa, es decir, que debe estar formada por todas las señales leídas dentrodel proceso.

Ø Subprogramas.

ü Especifican lógica combinacional siempre.� Independientemente de que se les llame en entornos secuenciales o concurrentes.

� Independientemente de cómo esten codificados internamente.

⌦ Para asegurar que el diseño especificado es síncrono:Ø Ningún conjunto de señales asignadas por construcciones que especifiquen lógica

combinacional pueden formar un lazo, es decir, una señal ‘combinacional’ no puede formarparte de la expresión que la define, en caso contrario se sintetizaría lógica asíncrona.

47


especificación de especificación de HWHW secuencial (i) secuencial (i)

⌦ La lógica secuencial se especifica mediante:Ø Procesos que contengan una o varias sentencias wait.

ü Las únicas clases de sentencias wait permitidas son:� wait until CLK = ’1’;

� wait until CLK’event and CLK = ’1’;

� wait until not CLK’stable and CLK = ’1’;

ü Sólo puede especificarse lógica secuencial con temporización disparada por flanco.

ü Se especifican elementos de almacenamiento para:� Toda señal escrita por el proceso.

� Toda variable que en alguna activación sea leída antes que escrita.

Ø Procesos que no contengan wait, tales que:

ü Existan algunas señales o variables escritas por el proceso que no se asignen bajoalguna condición de ejecución del mismo.� Dichas señales especificarán elementos de almacenamiento

� Las condiciones que regulan su actualización determinarán la clase de elemento secuencial.

ü Puede especificarse cualquier lógica secuencial con temporización de cualquier tipo.

ü Para asegurar la coherencia entre simulación y síntesis, la lista de sensibilidad debeser parcial, estando formada por todas aquellas señales que disparan cambios deestado (i.e: reloj, reset, clear, etc ... ).

48


especificación deespecificación de HW HW secuencial ( secuencial (iiii): método): método

LC

LC

LC

lógica de generacióndel estado siguiente

lógica de generacióndel salidas tipo Moore

lógica de generacióndel salidas tipo Mealy

registro de estado

⌦ Según el modelo de Huffman, cualquier sistema secuencial puede considerarse formado por 2únicos elementos:Ø Un único registro de estado (que agrupa todos los elementos de memoria primitivos del sistema).Ø Una red combinacional que realiza los cálculos.

⌦ Ampliando dicho modelo puede obtenerse un método fiable de especificación de sistemassecuenciales en VHDL. Todo sistema secuencial lo consideraremos formado por 4 elementos:Ø Un registro de estado.Ø Una red combinacional que calcula el estado siguiente.Ø Una red combinacional que calcula las salidas que sólo dependen del estado (tipo Moore).Ø Una red combinacional que calcula las salidas que dependen del estado y de la entrada (tipo Mealy).

49


especificación deespecificación de HW HW secuencial ( secuencial (iiiiii): método): método

LC

LC

LC

statestateGen mooreGen

mealyGen

nextState

currentStateinput

mealyOutput

mooreOutput

primera alternativa

Utilizar un proceso por elemento a especificar.

50


especificación deespecificación de HW HW secuencial ( secuencial (iviv): método): método

state:process( clk, rst )begin if (rst = ‘1’) then currentState <= ...; elsif (clk’event and clk=‘1’) then currentState <= nextState; end if;end process;

mealyGen:process( currentState, input )begin mealyOutput <= ...; case currentState is when ... => if (input ...) then mealyOutput <= ... elsif (input ...) then ... else ... end if; ... end case;end process;

mooreGen:process( currentState )begin mooreOutput <= ...; case currentState is when ... => mooreOutput <= ... ... end case;end;

stateGen:process( currentState, input )begin nextState <= currentState; case currentState is when ... => if (input ...) then nextState <= ...; elsif (input ...) then ... else ... end if; ... end case;end process;

valor por defecto de las señales asignadas por el proceso,asegura que se implemente como combinacional

51


especificación deespecificación de HW HW secuencial (v): método secuencial (v): método

LC

LC

LC

state mooreGen

mealyOutput

mooreOutput

stateGen_mealyGen

input

nextState

currentState

Dado que el cálculo del estado siguiente y el cálculo delas salidas tipo Mealy tienen estructuras equivalentespueden agruparse en un único proceso.

segunda alternativa

52


especificación deespecificación de HW HW secuencial (vi): método secuencial (vi): método



stateGen_mealyGen:process( currentState, input )begin nextState <= currentState; mealyOutput <= ...; case currentState is when ... => if (input ...) then nextState <= ...; mealyOutput <= ... elsif (input ...) then ... else ... end if; ... end case;end process;

53


especificación deespecificación de HW HW secuencial ( secuencial (viivii): método): método

LC

LC

LC

state

mealyOutput

mooreOutput

stateGen_mealyGen_mooreGen

input

nextState

currentState

Modelo de Huffman: lógica combinacional y lógicasecuencial separada.

tercera alternativa

54


especificación deespecificación de HW HW secuencial ( secuencial (viiiviii): método): método


stateGen_mealyGen_mooreGen:process( currentState, input )begin nextState <= currentState; mealyOutput <= ...; mooreOutput <= ...; case currentState is when ... => mooreOutput <= ... if (input ...) then nextState <= ...; mealyOutput <= ... elsif (input ...) then ... else ... end if; ... end case;end process;

las salidas tipo Moore sólo dependen del estado

el estado siguiente y las salidas tipo Mealydependen del estado y de las entradas

55


Dado que el cambio de estado solo se haceefectivo tras eventos del reloj, el cálculo delestado siguiente se puede especificar local alproceso que almacena el estado

especificación deespecificación de HW HW secuencial ( secuencial (ixix): método): método

LC

LC

LC

stateGen_state

mooreGen

mealyGencurrentStateinput mealyOutput

mooreOutput

cuarta alternativa

56


especificación deespecificación de HW HW secuencial (x): método secuencial (x): métodomealyGen:process( currentState, input )begin mealyOutput <= ...; case currentState is when ... => if (input ...) then mealyOutput <= ... elsif (input ...) then ... else ... end if; ... end case;end process;


stateGen_state:process( clk, rst, input )begin if (rst = ‘1’) then currentState <= ...; elsif (clk’event and clk=‘1’) then currentState <= ...; case currentState is when ... => if (input ...) then currentState <= ...; elsif (input ...) then ... else ... end if; ... end case; end if;end process;

el calculo del nuevo estado actual en función del estadoactual (currentState es una señal) debe formar parte de

la rama then de la especificación de flanco

estado al que se salta por defecto (puede sersobreescrito por posteriores asignaciones)

podría suprimirse

57


especificación deespecificación de HW HW secuencial (xi): método secuencial (xi): método

LC

LC

LC

stateGen mooreGen_state

mealyGen

nextState

currentStateinput

mealyOutput

mooreOutputUnir el proceso que almacena el estadocon el que calcula las salidas tipo Moore.

cuarta alternativa

58


especificación deespecificación de HW HW secuencial ( secuencial (xiixii): método): método

mooreGen_state:process( clk, rst, currentState )begin mooreOutput <= ...; case currentState is when ... => mooreOutput <= ... ... end case; if (rst = ‘1’) then currentState <= ...; elsif (clk’event and clk=‘1’) then currentState <= nextState; end if;end process;

mealyGen:process( currentState, input )begin mealyOutput <= ...; case currentState is when ... => if (input ...) then mealyOutput <= ... elsif (input ...) then ... else ... end if; ... end case;end process;

stateGen:process( currentState, input )begin nextState <= currentState; case currentState is when ... => if (input ...) then nextState <= ...; elsif (input ...) then ... else ... end if; ... end case;end process;

necesaria para que simule correctamente

el cálculo de la salida se realiza incondicionalmente,si se anidara dentro del if, se interpretaría quedichas salidas hay también que almacenarlas

(aunque sólo cambien tras el cambio de estado)

59


especificación deespecificación de HW HW secuencial ( secuencial (xiiixiii): método): método

LC

LC

LC

mooreGen

mealyOutput

mooreOutput

stateGen_mealyGen_state

input

currentState

quinta alternativa

60


especificación deespecificación de HW HW secuencial ( secuencial (xivxiv): método): métodomooreGen:process( currentState )begin mooreOutput <= ...; case currentState is when ... => mooreOutput <= ... end case;end;

stateGen_MealyGen_state:process( clk, rst, currentState, input )begin mealyOutput <= ...; case currentState is when ... => if (input ...) then mealyOutput <= ... elsif (input ...) then ... else ... end if; ... end case; if (rst = ‘1’) then currentState <= ...; elsif (clk’event and clk=‘1’) then currentState <= ...; case currentState is when ... => if (input ...) then currentState <= ...; elsif (input ...) then ... else ... end if; ... end case; end if;end process;



el calculo del nuevo estado actual en función del estadoactual forma parte de la rama then de la especificación

de flanco

el cálculo de la salida se realiza incondicionalmente,(ahora puede cambiar aunque no cambie el estado)

61


especificación deespecificación de HW HW secuencial ( secuencial (xvxv): método): método

LC

LC

LC

mealyOutput

mooreOutput

stateGen_mealyGen_mooreGen_state

input

currentState

sexta alternativa

Utilizar un único proceso.

62


especificación deespecificación de HW HW secuencial ( secuencial (xvixvi): método): métodostateGen_mealyGen_mooreState_state:process( clk, rst, currentState, input )begin mealyOutput <= ...; mooreOutput <= ...; case currentState is when ... => mooreOutput <= ... if (input ...) then mealyOutput <= ... elsif (input ...) then ... else ... end if; ... end case; if (rst = ‘1’) then currentState <= ...; elsif (clk’event and clk=‘1’) then currentState <= ...; case currentState is when ... => if (input ...) then currentState <= ...; elsif (input ...) then ... else ... end if; ... end case; end if;end process;

el cálculo de la salida se realiza incondicionalmente

el calculo del nuevo estado actual en función del estadoactual forma parte de la rama then de la especificación

de flanco

Aunque resulte poco intuitivo, este es el método fiablede especificación de HW a nivel RT más abstracto,

existen otros pero son difíciles de controlar

63


multiplexormultiplexor vectorial 2 a 1 vectorial 2 a 1

library IEEE; use IEEE.std_logic_1164.all;

entity multiplexer is port( x0 : in std_logic_vector( 7 downto 0 ); x1 : in std_logic_vector( 7 downto 0 ); sel : in std_logic; y : out std_logic_vector( 7 downto 0 ) );end multiplexer;

architecture syn1 of multiplexer isbegin y <= x1 when (sel = ‘1’) else x0;end syn;

architecture syn2 of multiplexer isbegin process( sel, x0, x1 ) begin if sel=‘1’ then y <= x1; else y <= x0; end if;end syn3;

architecture syn3 of multiplexer is signal aux : std_logic_vector( 7 downto 0 );begin aux <= (others=>sel); y <= (x1 and aux) or (x0 and not aux);end syn2;

implica una estructurade nivel lógico

64


multiplexormultiplexor vectorial genérico 2 a 1 vectorial genérico 2 a 1


entity multiplexer is generic( n : integer := 8 ); port( x0 : in std_logic_vector( n-1 downto 0 ); x1 : in std_logic_vector( n-1 downto 0 ); sel : in std_logic; y : out std_logic_vector( n-1 downto 0 ) );end multiplexer;

architecture syn of multiplexer isbegin process( sel, x0, x1 ) begin if sel=‘1’ then y <= x1; else y <= x0; end if;end syn3;

65


codificador de prioridad 8 a 3 (i)codificador de prioridad 8 a 3 (i)library IEEE; use IEEE.std_logic_1164.all;

entity priorityEncoder is port( x : in std_logic_vector( 7 downto 0 ); y : out std_logic_vector( 2 downto 0 ); gs : out std_logic );end priorityEncoder;

architecture syn of priorityEncoder isbegin process( x ) begin if x(7)=‘1’ then y <= “111”; gs <= ‘1’; elsif x(6)=‘1’ then y <= “110”; gs <= ‘1’; elsif x(5)=‘1’ then y <= “101”; gs <= ‘1’; elsif x(4)=‘1’ then y <= “100”; gs <= ‘1’; elsif x(3)=‘1’ then y <= “011”; gs <= ‘1’; elsif x(2)=‘1’ then y <= “010”; gs <= ‘1’; elsif x(1)=‘1’ then y <= “001”; gs <= ‘1’; elsif x(0)=‘1’ then y <= “000”; gs <= ‘1’; else y <= “000”; gs <= ‘0’; end if; end process;end syn;

la respuesta cuando no hay entradasactivadas se especifica en la última rama else

la anidación de if especificala prioridad de las entradas

x(7) se chequea en primer lugares el más prioritario

el proceso se activa cuando hay un evento en cualquiera

de las componentes de x

66


codificador de prioridad 8 a 3 (codificador de prioridad 8 a 3 (iiii))


entity priorityEncoder is port( x : in std_logic( 7 downto 0 ); y : out std_logic_vector( 2 downto 0 ); gs : out std_logic );end priorityEncoder;

architecture syn of priorityEncoder isbegin process( x ) begin y <= “000”; gs <= ‘0’; if x(0)=‘1’ then y <= “000”; gs <= ‘1’; end if; if x(1)=‘1’ then y <= “001”; gs <= ‘1’; end if; if x(2)=‘1’ then y <= “010”; gs <= ‘1’; end if; if x(3)=‘1’ then y <= “011”; gs <= ‘1’; end if; if x(4)=‘1’ then y <= “100”; gs <= ‘1’; end if; if x(5)=‘1’ then y <= “101”; gs <= ‘1’; end if; if x(6)=‘1’ then y <= “110”; gs <= ‘1’; end if; if x(7)=‘1’ then y <= “111”; gs <= ‘1’; end if; end process;end syn;

valores ‘por defecto’ de lassalidas cuando no hay entradas

activadas

la prioridad de las entradas se especificasobreescribiendo selectivamente el valor

asignado por anteriores sentencias

x(7) se chequea en último lugares el más prioritario

67


codificador de prioridad genéricocodificador de prioridad genéricolibrary IEEE;use IEEE.std_logic_1164.all;use IEEE.std_logic_arith.all;

entity priorityEncoder is generic( n : integer := 3 ); port( x : in std_logic( 2**n-1 downto 0 ); y : out std_logic_vector( n-1 downto 0 ); gs : out std_logic );end priorityEncoder;

architecture syn of priorityEncoder isbegin process( x ) begin y <= (others=>’0’); gs <= ‘0’; for i in x’reverse_range loop if x(i)=‘1’ then y <= conv_std_logic_vector( i, n ); gs <= ‘1’; end if; end loop; end process;end syn;

el rango de i es computable yel bucle puede desenrrollarse

la prioridad de las entradas se especificasobreescribiendo selectivamente el valor

asignado por anteriores sentencias

presente en paquete std_logic_arith

expresión computable

68


decodificador 3 a 8 (i)decodificador 3 a 8 (i)


entity decoder is port( x : in std_logic_vector( 2 downto 0 ); en : in std_logic; y : out std_logic( 7 downto 0 ) );end decoder;

architecture syn of decoder isbegin process( x, en ) begin y <= “00000000”; if en=‘1’ then case x is when “000” => y(0) <= ‘1’; when “001” => y(1) <= ‘1’; when “010” => y(2) <= ‘1’; when “011” => y(3) <= ‘1’; when “100” => y(4) <= ‘1’; when “101” => y(5) <= ‘1’; when “110” => y(6) <= ‘1’; when “111” => y(7) <= ‘1’; end case; end if; end process;end syn;

la selección se anida dentro de la habilitacióndefine un reuso de los cálculos intermedios

e implica una estructura en cascada

69


decodificador 3 a 8 (decodificador 3 a 8 (iiii))


entity decoder is port( x : in std_logic_vector( 2 downto 0 ); en : in std_logic; y : out std_logic( 7 downto 0 ) );end decoder;

architecture syn of decoder isbegin y(0) <= ‘1’ when (en=‘1’ and x=“000”) else ‘0’; y(1) <= ‘1’ when (en=‘1’ and x=“001”) else ‘0’; y(2) <= ‘1’ when (en=‘1’ and x=“010”) else ‘0’; y(3) <= ‘1’ when (en=‘1’ and x=“011”) else ‘0’; y(4) <= ‘1’ when (en=‘1’ and x=“100”) else ‘0’; y(5) <= ‘1’ when (en=‘1’ and x=“101”) else ‘0’; y(6) <= ‘1’ when (en=‘1’ and x=“110”) else ‘0’; y(7) <= ‘1’ when (en=‘1’ and x=“111”) else ‘0’;end syn;

cada salida se asigna por separado

no se comparte la expresión de habilitaciónluego implica una estructura paralela

70


decodificadordecodificador generico generico

library IEEE;use IEEE.std_logic_1164.all;use IEEE.std_logic_arith.all;

entity decoder is generic( n : integer := 3 ); port( x : in std_logic_vector( n-1 downto 0 ); en : in std_logic; y : out std_logic( 2**n-1 downto 0 ) );end decoder;

architecture syn of decoder isbegin process( x, en ) begin y <= (others=>’0’); if en=‘1’ then y( conv_integer( unsigned(x) ) ) <= ‘1’; end if; end process;end syn;

presente en paquete std_logic_arith

las conversiones de tipo no requieren HWya que sólo indican cómo debe interpretarse z

71


sumador genérico (i)sumador genérico (i)


entity adder is generic( n : integer := 8 ); port( x, y : in std_logic( n-1 downto 0 ); cin : in std_logic; s : out std_logic_vector( n-1 downto 0 ); cout : out std_logic );end adder;

architecture syn of adder is signal c : std_logic_vector( n downto 0 );begin c(0) <= cin; for i in s’reverse_range generate s(i) <= x(i) xor y(i) xor c(i); c(i+1) <= (x(i) and y(i)) or ((x(i) xor y(i)) and c(i)); end generate; cout <= c(n);end syn;

comienza a calcular por el bit menos significativo

colección de señales intermedias paraconectar los acarreos intermedios

implica una estructura lógica

72


sumador genérico (sumador genérico (iiii))library IEEE; use IEEE.std_logic_1164.all;


architecture syn of adder is function xor( constant x : in std_logic_vector ) return std_logic is variable y : std_logic := ‘0’; begin for i in x’range loop y := y xor x(i); end loop; return y; end xor; signal c : std_logic_vector( n downto 0 );begin c(0) <= cin; for i in s’reverse_range generate s(i) <= xor( x(i)&y(i)&c(i) ); c(i+1) <= (x(i) and y(i)) or ( xor( x(i)&y(i) ) and c(i)); end generate; cout <= c(n);end syn;

esta función especifica el compotamientode una puerta xor genérica de n entradas

cada llamada es una instanciadiferentedel HW combinacional

que implementa la función

73


sumador genérico (sumador genérico (iiiiii))



architecture syn of adder isbegin process( x, y, cin ) variable c : std_logic; begin c := cin; for i in s’reverse_range loop s(i) <= x(i) xor y(i) xor c; c := (x(i) and y(i)) or ((x(i) xor y(i)) and c); end loop; cout := c; end process;end syn;

comienza a calcular por el bit menos significativo

variable intermedia que propagael acarreo de una iteración a otra

74


sumador genérico (sumador genérico (iviv))

library IEEE;use IEEE.std_logic_1164.all;use IEEE.std_logic_unsigned.all;

entity adder is generic( n : integer := 8 ); port( x, y : in std_logic_vector( n-1 downto 0 ); cin : in std_logic; s : out std_logic_vector( n-1 downto 0 ); cout : out std_logic );end adder;

architecture syn of adder is signal temp : std_logic_vector (n downto 0);begin temp <= ( ‘0’ & x ) + y + std_logic_vector(cin); s <= temp(n-1 downto 0); cout <= temp(n);end syn;

Cuando se desee obtener el bit de acarreoresultante de una operación de suma o resta

deberá extenderse 1 bit el operando más ancho.

Recuérdese que el resultado de la suma definidaen std_logic_unsigned tiene la misma anchura

que el mayor de los argumentos

esta especificación no implicaninguna estructura lógica

75


sumador genérico (v)sumador genérico (v)library IEEE;use IEEE.std_logic_1164.all;

package rtModules is procedure rippleAdder( constant x, y: in std_logic_vector; constant cin : in std_logic; signal s : out std_logic_vector; signal cout : out std_logic );end rtModules;

package body rtModules is procedure rippleAdder( constant x, y: in std_logic_vector; constant cin : in std_logic; signal s : out std_logic_vector; signal cout : out std_logic ) is variable c : std_logic; begin c := cin; for i in 0 to s’high-s’low loop s(i+s’low) <= x(i+x’low) xor y(i+y’low) xor c; c := (x(i+x’low) and y(i+y’low)) or ((x(i+x’low) xor y(i+y’low)) and c); end loop; cout <= c; end;end rtModules;

76


sumador genérico (vi)sumador genérico (vi)library IEEE; use IEEE.std_logic_1164.all;use work.rtModules.all;


architecture syn of adder isbegin process( x, y, cin ) begin rippleAdder( x, y, cin, s, cout ); end process;end syn;

architecture syn2 of adder isbegin rippleAdder( x, y, cin, s, cout ); end syn;

77


registro genérico (i)registro genérico (i)


entity register is generic( n : integer := 8 ); port( clk, rst, ld : in std_logic; din : in std_logic_vector( n-1 downto 0 ); dout : out std_logic_vector( n-1 downto 0 ) ); end register;

architecture syn of register is signal cs, ns : std_logic_vector( n-1 downto 0 );begin state: process( clk, rst ) begin if rst=‘1’ then cs <= (others=>‘0’); elsif clk’event and clk=‘1’ then cs <= ns; end if; end process; next_state: ns <= din when ld=‘1’ else cs; moore_output: dout <= cs;end syn;

78


registro genérico (registro genérico (iiii))



architecture syn of register isbegin process( clk, rst ) begin if rst=‘1’ then dout <= (others=>‘0’); elsif clk’event and clk=‘1’ then if ld=‘1’ then dout <= din; end if; end if; end process;end syn;

79


registro genérico (registro genérico (iiiiii))



architecture syn of register isbegin process begin wait until (clk’event and clk=‘1’); if rst=‘1’ then dout <= (others=>‘0’); elsif ld=‘1’ then dout <= din; end if; end process;end syn;

no es necesario, pero permite que el sintetizador localice el reloj

el reset es ahora síncrono

80


registro de desplazamiento genérico (i)registro de desplazamiento genérico (i)entity shiftRegister is generic( n : integer := 8 ); port( clk, rst, sht : in std_logic; din : in std_logic; dout : out std_logic_vector( n-1 downto 0 ) ); end shiftRegister;

architecture syn of shiftRegister is signal cs, ns : std_logic_vector( n-1 downto 0 );begin state: process( clk, rst ) begin if rst=‘1’ then cs <= (others=>‘0’); elsif clk’event and clk=‘1’ then cs <= ns; end if; end process; next_state: process( cs, sht, din ) begin ns <= cs; if sht=‘1’ then for i in ns’high downto ns´low+1 loop ns(i) <= cs(i-1); end loop; ns(0) <= din; end if; end process; moore_output:dout <= cs;end syn;

81


registro de desplazamiento genérico (registro de desplazamiento genérico (iiii))

entity shiftRegister is generic( n : integer := 8 ); port( clk, rst, sht : in std_logic; din : in std_logic; dout : out std_logic_vector( n-1 downto 0 ) ); end shiftRegister;

architecture syn of shiftRegister is signal cs : std_logic_vector( n-1 downto 0 );begin process( clk, rst ) begin if rst=‘1’ then cs <= (others=>‘0’); elsif clk’event and clk=‘1’ then if sht=‘1’ then for i in cs’high downto cs´low+1 loop cs(i) <= cs(i-1); end loop; cs(0) <= din; end if; end if; end process; dout <= cs;end syn;

al ser señales podría hacerse tambiénal revés sin sobreescribir los valores actuales

82


registro de desplazamiento genérico (registro de desplazamiento genérico (iiiiii))

entity shiftRegister is generic( n : integer := 8 ); port( clk, rst, sht : in std_logic; din : in std_logic; dout : buffer std_logic_vector( n-1 downto 0 ) ); end shiftRegister;

architecture syn of shiftRegister isbegin process( clk, rst ) begin if rst=‘1’ then dout <= (others=>‘0’); elsif clk’event and clk=‘1’ then if sht=‘1’ then for i in ns’high downto ns´low+1 loop dout(i) <= dout(i-1); end loop; dout(0) <= din; end if; end if; end process;end syn;

siendo de tipo buffer, es un puerto de salidaque internamente puede ser leído; esto evita

que se declare la señal intermecia cs

83


registro genérico con salida en alta impedancia (i)registro genérico con salida en alta impedancia (i)

entity bufferRegister is generic( n : integer := 8 ); port( clk, rst, ld, en : in std_logic; din : in std_logic_vector( n-1 downto 0 ); dout : out std_logic_vector( n-1 downto 0 ) ); end bufferRegister;

architecture syn of register is signal cs, ns : std_logic_vector( n-1 downto 0 );begin state: process( clk, rst ) begin if rst=‘1’ then cs <= (others=>‘0’); elsif clk’event and clk=‘1’ then cs <= ns; end if; end process; next_state: ns <= din when ld=‘1’ else cs; mealy_output: dout <= cs when en=‘1’ else (others=>‘Z’);end syn;

84


registro genérico con salida en alta impedancia (registro genérico con salida en alta impedancia (iiii))

entity bufferRegister is generic( n : integer := 8 ); port( clk, rst, ld, en : in std_logic; din : in std_logic_vector( n-1 downto 0 ); dout : out std_logic_vector( n-1 downto 0 ) ); end bufferRegister;

architecture syn of register is signal cs : std_logic_vector( n-1 downto 0 );begin process( clk, rst, en ) begin dout <= (others=>‘Z’); if en=‘1’ then dout <= cs; end if; if rst=‘1’ then cs <= (others=>‘0’); elsif clk’event and clk=‘1’ then if ld=‘1’ then cs <= din; end if; end if; end process;end syn;

la señal cs se necesita para distinguir el estadoque puede inicializarse y cargarse de modo

independiente a la salida que puede desabilitarse

85


registro genérico con salida en alta impedancia (registro genérico con salida en alta impedancia (iiiiii))

process( clk, rst, en )begin if en=‘0’ then dout <= (others=>‘Z’); elsif rst=‘1’ then dout <= (others=>‘0’); elsif clk’event and clk=‘1’ then ... end if;end process;

process( clk, rst, en )begin if rst=‘1’ then dout <= (others=>‘0’); elsif en=‘0’ then dout <= (others=>‘Z’); elsif clk’event and clk=‘1’ then ... end if;end process;

process( clk, rst, en )begin if rst=‘1’ then dout <= (others=>‘0’); elsif clk’event and clk=‘1’ then ... elsif en=‘0’ then dout <= (others=>‘Z’); end if;end process;

error: sólo se incializa si en es ‘1’

en debe de estar en la lista de sendibilidadya que eventos asíncronos de en afectan a la salida

error: sólo carga nuevos valoresi en es ‘1’,luego no se permitiría la desabilitación

y carga de nuevos datos en paralelo

error: no existe HW real capaz de detectar la ausencia de flanco

process( clk, rst, en )begin if rst=‘1’ then dout <= (others=>‘0’); elsif clk’event and clk=‘1’ then ... end if; if en=‘0’ then dout <= (others=>‘Z’); end if;end process;

error: la ultima asignación en un proceso sobreescribelas anteriores, luego si en vale ‘1’ ni resetea ni carga

86


contador ascendente/descendente genérico (i)contador ascendente/descendente genérico (i)

entity counter is generic( n : integer := 8 ); port( clk, rst, ld, inc, dec : in std_logic; din : in std_logic_vector( n-1 downto 0 ); tca, tcd : out std_logic; dout : out std_logic_vector( n-1 downto 0 ) ); end register;

architecture syn of register is signal cs, ns : std_logic_vector( n-1 downto 0 );begin state: process( clk, rst ) begin if rst=‘1’ then cs <= (others=>‘0’); elsif clk’event and clk=‘1’ then cs <= ns; end if; end process; next_state: process( cs, ld, inc, dec, din ) begin if ld=‘1’ then ns <= din; elsif inc=‘1’ then ns <= cs + 1; elsif dec=‘1’ then ns <= cs - 1; else ns <= cs; end if; end process; moore_output: dout <= cs; mealy_output: block tca <= inc and cs = (others=>’1’); tcd <= dec and cs = (others=>’0’): end block;end syn;

no es necesario detectar el final de cuenta

se especifican las prioridades delas entradas de control

87


contador ascendente/descendente genérico (contador ascendente/descendente genérico (iiii))

entity counter is generic( n : integer := 8 ); port( clk, rst, ld, inc, dec : in std_logic; din : in std_logic_vector( n-1 downto 0 ); tca, tcd : out std_logic; dout : out std_logic_vector( n-1 downto 0 ) ); end register;

architecture syn of register is signal cs : std_logic_vector( n-1 downto 0 );begin process( clk, rst, cs, ld, inc, dec, din ) begin tca <= inc and cs = (others=>’1’); tcd <= dec and cs = (others=>’0’); dout <= cs; if rst=‘1’ then cs <= (others=>‘0’); elsif clk’event and clk=‘1’ then if ld=‘1’ then cs <= din; elsif inc=‘1’ then cs <= cs + 1; elsif dec=‘1’ then cs <= cs - 1; end if; end if; end process;end syn;

88


contador módulo ascendente/descendente genéricocontador módulo ascendente/descendente genérico

entity counter is generic( n : integer := 8 max_value, min_value : integer := 0 ); port( clk, rst, ld, inc, dec : in std_logic; din : in std_logic_vector( n-1 downto 0 ); tca, tcd : out std_logic; dout : out std_logic_vector( n-1 downto 0 ) ); end register;

architecture syn of register is signal cs : std_logic_vector( n-1 downto 0 );begin process( clk, rst, cs, ld, inc, dec, din ) begin tca <= inc and cs = max_value; tcd <= dec and cs = min_value; dout <= cs; if rst=‘1’ then cs <= conv_std_logic_vector( min_value, n ); elsif clk’event and clk=‘1’ then if ld=‘1’ then cs <= din; elsif inc=‘1’ then if cs = max_value then cs <= conv_std_logic_vector( min_value, n ); else cs <= cs + 1; end if; elsif dec=‘1’ then if cs = min_value then cs <= conv_std_logic_vector( max_value, n ); else cs <= cs - 1; end if; end if; end if; end process;end syn;

89


sistemasistema algorítmico algorítmico (i): especificación (i): especificación

⌦ Se desea diseñar un sistema digital que controle ‘inteligentemente’ los semáforosque hay en el cruce entre una carretera principal y una secundaria, tal que laprimera sea prioritaria sobre la segunda.Ø Debe asegurar que nunca ambos semáforos están en verde simultáneamente.Ø El semáforo principal estará verde como mínimo un peridoVerde y continuará en verde

hasta que no se detecten coches en la vía secundaria.Ø Si hubiera coches en la vía secundaria, y sólo si el semáforo principal ha estado en verde

durante un peridoVerde completo, el semáforo principal pasará a amarillo durante unperiodoAmarillo, tras el cual se pondrá en rojo y el semáforo secundario en verde.

Ø El semáforo secundario nunca permanecerá en verde más de un periodoVerde, tras el cualpasará a amarillo durante un periodoAmarillo y una vez finalizado éste, pasará a rojo.Entonces el semáforo principal pasará a verde.

Ø No obstante si durante el periodoVerde del semáforo secundario la vía secundaria sequedara vácia, no se esperará a consumir el tiempo y se disparará la transición delsemáforo secundario a amarillo.

detector de presencia

semáforo secundariosemáforo principal

vía secundaria

vía principal

90


sistemasistema algorítmico algorítmico ( (iiii): estructura): estructura

controlador temporizadorperiodoAmarillo

periodoVerde

fin

cargar

periodo

clk

rst

semPrin

semSec

n

n3

3

hayCoche

Contador descendente no-cíclico con: - reset asíncrono, - carga síncrona seleccionable entre 2 valores - con detector de fin de cuenta

TEMPORIZADOR

Máquina de estados finitos - reset asíncrono, - 5 estados en correspondencia con el estado de los semáforos.

CONTROLADOR

viene del detector de presencia

van al semaforo secundario (1 línea por bombilla)

van al semaforo principal (1 línea por bombilla)

vienen de switches externos

91


sistemasistema algorítmico algorítmico ( (iiiiii): temporizador ): temporizador RTRT

1 0

1 0

periodoVerde

periodoAmarillo

periodo

cargar

igual a 0

restar 1

fin

clk

rst

1 0

92


sistemasistema algorítmico algorítmico ( (iviv): controlador ): controlador RTRT

semPrin ← verdesemSec ← rojo

semPrin ← verdesemSec ← rojo

semPrin ← amarillosemSec ← rojo

semPrin ← rojosemSec ← verde

semPrin ← rojosemSec ← amarillo

no fin

no hayCoche

no fin

fin

hayCoche y no fin

no fin

hayCoche

cargar peridoAmarillo

no hayCoche o fin

cargar peridoAmarillo

cargar peridoVerde

fin

cargar peridoVerde

fin

el semáforo principal está en verdedurante un periodoVerde completo

el semáforo principal permanece enverde hasta que se dectecte un

coche en la vía secundaria

transición de verde a rojoen el semáforo principal

transición de verde arojo del semáforo

secundariopVsR

pAsR pRsV

pRsApVsRCondel semáforo secundario permaneceen verde mientras haya coches y nohaya consumido su periodoVerde

93


sistemasistema algorítmico algorítmico (v): interfaz (v): interfaz VHDLVHDL

library IEEE;use IEEE.std_logic_1164.all;use IEEE.std_logic_unsigned.all;

entity controlSemaforos is generic( n : integer := 16 ); port( clk, rst : in std_logic; hayCoche : in std_logic; periodoVerde, periodoAmarillo : in std_logic_vector( n-1 downto 0 ); semPrin, semSec : out std_logic_vector( 2 downto 0 ) );end controlSemaforos;

architecture syn of controlSemaforos is

type estados_t is ( pVsR, pVsRCond, pAsR, pRsV, pRsA ); constant rojo : std_logic_vector( 2 downto 0 ) := “100”; constant amarillo : std_logic_vector( 2 downto 0 ) := “010”; constant verde : std_logic_vector( 2 downto 0 ) := “001”;

signal cargar, periodo, fin : std_logic; signal csT, nsT : std_logic_vector( n-1 downto 0 ); signal csC, nsC : estados_t;

begin ...end controlSemaforos;

todos los datos numéricos son positivos, luego los objetosde tipo std_logic_vector deben interpretarse sin signo

declarando el estado del controlador como un tipoenumerado permite que la herramienta seleccione la

codificación de estados más adecuada

el uso de constantes clarifica el código

estado (cuenta) del temporizador

estado del controlador

94


stateGenTemporizador:process( csT, fin, cargar, periodo, periodoVerde, periodoAmarillo )begin if cargar = ‘1’ then if periodo = ‘1’ then nsT <= periodoAmarillo; else nsT <= periodoVerde; end if; else if fin = ‘1’ then nsT <= csT; else nsT <= csT - 1; end if; end if;end process;

mooreGenTemporizador:process( csT )begin if csT = (others => ’0’) then fin <= ‘1’; else fin <= ‘0’; end if;end process;

sistemasistema algorítmico algorítmico (vi): temporizador (vi): temporizador VHDLVHDL

stateTemporizador:process( clk, rst )begin if rst = ‘1’ then csT <= (others => ‘0’); elsif clk’event and clk=‘1’ then csT <= nsT; end if;end process;

las asignaciones de reset asíncronodeben ser estáticas, si fuera síncrono

podría inializarse a periodoVerde

95


sistemasistema algorítmico algorítmico ( (viivii): controlador ): controlador VHDLVHDL

stateGenControlador:process( csC, hayCoche, fin )begin case csC is nsC <= csC; when pVsR => if fin = ‘1’ then nsC <= pVsRCond; end if; when pVsRCond => if hayCoche = ‘1’ then nsC <= pAsR; end if; when pAsR => if fin = ‘1’ then nsC <= pRsV; end if; when pRsV => if hayCoche = ‘0’ or fin = ‘1’ then nsC <= pRsA; end if; when pRsA => if fin = ‘1’ then nsC <= pVsr; end if; end case;end process;

por defecto se permanece en el mismo estado

cuando se detectan cambios en lasseñales el estado cambia

96


sistemasistema algorítmico algorítmico ( (viiiviii): controlador): controlador VHDL VHDL

mealyGenControlador:process( csC, hayCoche, fin )begin cargar <= ‘0’; periodo <= ‘-’; case csC is when pVsR => null; when pVsRCond => if hayCoche = ‘1’ then cargar <= ‘1’; periodo <= ‘1’; end if; when pAsR => if fin = ‘1’ then cargar <= ‘1’; periodo <= ‘0’; end if; when pRsV => if hayCoche = ‘0’ or fin = ‘1’ then cargar <= ‘1’; periodo <= ‘1’; end if; when pRsA => if fin = ‘1’ then cargar <= ‘1’; periodo <= ‘0’; end if; end case;end process;

por defecto el temporizador no debe cargar nada, yaque según su diseño la carga es prioritaria a la cuenta

si no carga el valor de periodo es indiferente

en el estado pVsR nunca se carga nada

97


sistemasistema algorítmico algorítmico ( (ixix): controlador): controlador VHDL VHDL

mooreGenControlador:process( csC )begin case csC is when pVsR => semPrin <= verde; semSec <= rojo; when pVsRCond => semPrin <= verde; semSec <= rojo; when pAsR => semPrin <= amarillo; semSec <= rojo; when pRsV => semPrin <= rojo; semSec <= verde; when pRsA => semPrin <= rojo; semSec <= amarillo; end case;end process;

stateControlador:process( clk, rst )begin if rst = ‘1’ then csC <= pVsR; elsif clk’event and clk=‘1’ then csC <= nsC; end if;end process;

no hace falta asignar un valor por defecto para semPriny semSec ya que se asignan en todos los casos

98


temporizador:process( clk, rst, csT, fin, cargar, periodo, periodoVerde, periodoAmarillo )begin if csT = (others => ’0’) then fin <= ‘1’; else fin <= ‘0’; end if; if rst = ‘1’ then csT <= (others => ‘0’); elsif clk’event and clk=‘1’ then if cargar = ‘1’ then if periodo = ‘1’ then csT <= periodoAmarillo; else csT <= periodoVerde; end if; else if fin = ‘1’ then csT <= csT; else csT <= csT - 1; end if; end if; end if;end process;

sistemasistema algorítmico algorítmico (x): otro temporizador (x): otro temporizador VHDLVHDL

99


sistemasistema algorítmico algorítmico (xi): otro controlador (xi): otro controlador VHDLVHDL

controlador:process( clk, rst, csC, hayCoche, fin )begin cargar <= ‘0’; periodo <= ‘-’; case csC is when pVsR => semPrin <= verde; semSec <= rojo; when pVsRCond => semPrin <= verde; semSec <= rojo; if hayCoche = ‘1’ then cargar <= ‘1’; periodo <= ‘1’; end if; when pAsR => semPrin <= amarillo; semSec <= rojo; if fin = ‘1’ then cargar <= ‘1’; periodo <= ‘0’; end if; when pRsV => semPrin <= rojo; semSec <= verde; if hayCoche = ‘0’ or fin = ‘1’ then cargar <= ‘1’; periodo <= ‘1’; end if; when pRsA => semPrin <= rojo; semSec <= amarillo; if fin = ‘1’ then cargar <= ‘1’; periodo <= ‘0’; end if; end case; ...

...if rst = ‘1’ then csC <= pVsR; elsif clk’event and clk=‘1’ then case csC is when pVsR => if fin = ‘1’ then csC <= pVsRCond; end if; when pVsRCond => if hayCoche = ‘1’ then csC <= pAsR; end if; when pAsR => if fin = ‘1’ then csC <= pRsV; end if; when pRsV => if hayCoche = ‘0’ or fin = ‘1’ then csC <= pRsA; end if; when pRsA => if fin = ‘1’ then csC <= pVsr; end if; end case; end if;end process;

100


bibliotecas de bloques bibliotecas de bloques prediseñadosprediseñados (i) (i)

⌦ Los componentes de una biblioteca DesignWare son una colección de bloquesconstructivos prediseñados, de alto nivel, independientes de tecnología yparametrizables en tamaño, funcionalidad, implementación y rendimiento.Ø La implementación y el rendimiento los elije la herramienta de síntesis según las ligaduras

del diseño y las licencias disponibles.

Ø El tamaño y la funcionalidad se especifican desde VHDL mediante:

ü Instanciación directa

ü Inferencia (sólo bloques combinacionales) a partir de un operador o de una función.

⌦ Desde el punto de vista de la herramienta de síntesis se organizan en:Ø Standard Library: contiene los bloques usados por el VHDL Compiler para implementar

las distintas constructiones VHDL.

Ø Foundation Library: contiene implementaciones de alto rendimiento de los bloques de laStandard Library, junto con una colección de bloques avanzados.

ü Logic: bloques combinacionales y secuenciales básicos.

ü Math: bloques aritméticos y trigonométricos.

ü Memory: registros, RAMs (síncronas y asíncronas), colas y pilas.

ü Application Specific: integridad de datos, lógica de interfaz, componentes JTAG.

Ø DSP Library: contiene filtros digitales para aplicaciones de procesado de señal.

Ø GTECH (Generic TECHnology) Library: biblioteca de puertas independiente de tecnología.

⌦ Desde el punto del analizador de VHDL se organizan en 8 bibliotecas:Ø DW01, DW02, DW03, DW04, DW05, DW06, DW07 y GTECH

101


bibliotecas de bloquesbibliotecas de bloques prediseñados prediseñados ( (iiii))

DW01_binencDW01_bshDW01_cmp2DW01_cmp6DW01_decodeDW01_mux_anyDW01_prienc

DW03_bictr_dcntoDW03_bictr_scntoDW03_bictr_decodeDW03_cntr_grayDW03_lfsr_dcntoDW03_lfsr_scntoDW03_lfsr_loadDW03_lfsr_updnDW03_updn_ctr

Foundation Library: Logiccodificadordesplazador lógicocomparador de 2 funcionescomparador de 6 functionesdecodificadormultiplexorcodificador con prioridad

contador binario ascendente/descendente con límite dinámicocontador binario ascendente/descendente con límite estáticocontador binario ascendente/descendente con salida decodificadacontador en codigo Graycontador LFSR (linear feedback shift register) con límite dinámicocontador LFSR con límite estáticocontador LFSR con cargacontador LFSR ascendente/descendentecontador ascendente/descendente

com

bina

cion

ales

secu

enci

ales

biblioteca VHDL en la que se encuentra analizadoel modelo simulable del módulo

102


bibliotecas de bloquesbibliotecas de bloques prediseñados prediseñados ( (iiiiii))

DW01_absvalDW01_addDW01_addsubDW01_ashDW01_decDW02_divideDW01_incDW01_incdecDW02_macDW02_multDW02_mult_2_stageDW02_mult_3_stageDW02_mult_4_stageDW02_mult_5_stageDW02_mult_6_stageDW02_prod_sumDW02_prod_sum1DW02_rem restoDW01_satrndDW02_sqrt raizDW01_subDW02_sumDW02_treeDW_vhd_mod

DW02_cosDW02_sinDW02_sincos

Foundation Library: Mathvalor absolutosumadorsumador/restadordesplazador aritméticodecrementadordivisor combinacionalincrementadorincrementador/decrementadormultiplicador acumuladormultiplicadormultiplicador segmentado de 2 etapasmultiplicador segmentado de 3 etapasmultiplicador segmentado de 4 etapasmultiplicador segmentado de 5 etapasmultiplicador segmentado de 6 etapassuma generalizada de productosmultiplicador sumadorresto entero combinacionalsaturación y redondeo aritméticoraiz cuadrada combinacionalrestadorsumador vectorialcompresor para árboles de Wallacemodulo entero combinacional

coseno combinacionalseno combinacionalseno/coseno combinacional

aritm

étic

ostr

igon

omét

icos

103


bibliotecas de bloquesbibliotecas de bloques prediseñados prediseñados ( (iviv))

cola de registros para segmentaciónregistro con reset y capacitación síncronaregistro de desplazamientoregistro tipo Shadowsincronizador

RAM con escritura síncrona y lectura asíncrona basada en biestablesRAM con escritura síncrona y lectura asíncrona basada en latchesRAM con escritura síncrona y doble puerto de lectura asíncrona basada en biestablesRAM con escritura síncrona y doble puerto de lectura asíncrona basada en latchesRAM síncrona basado en biestablesRAM síncrona basado en latchesRAM asíncrona doble puerto basada en biestablesRAM asíncrona doble puerto basada en latchesRAM asíncrona triple puerto basada en biestablesRAM asíncrona triple puerto basada en latchesRAM asíncrona monopuerto basada en biestablesRAM asíncrona monopuerto basada en latches

DW03_pipe_regDW03_reg_s_plDW03_shftreg DW04_shad_regDW04_sync

DW_ram_r_w_s_dffDW_ram_r_w_s_latDW_ram_2r_w_s_dffDW_ram_2r_w_s_latDW_ram_rw_s_dffDW_ram_rw_s_latDW_ram_r_w_a_dffDW_ram_r_w_a_latDW_ram_2r_w_a_dffDW_ram_2r_w_a_latDW_ram_rw_a_dffDW_ram_rw_a_lat

Foundation Library: Memory

regi

stro

sR

AM

est

átic

as104


FIFO asimétrica síncrona con flags dinámicosFIFO asimétrica síncrona con flags estáticosFIFO asíncrona con flags dinámicosFIFO asíncrona con flags estáticosFIFO síncrona con flags dinámicosFIFO síncrona con flags estáticosFIFO síncrona (2 relojes) con flags estáticoscontrolador de FIFO asimétrica síncrona con flags dinámicoscontrolador de FIFO asimétrica síncrona con flags estáticoscontrolador de FIFO asíncrona con flags dinámicoscontrolador de FIFO asíncrona con flags estáticoscontrolador de FIFO síncrona con flags dinámicoscontrolador de FIFO síncrona con flags estáticoscontrolador de FIFO síncrona (2 relojes) con flags estáticoscontrolador de FIFO síncrona enlazada con flags dinámicos

LIFO síncronacontrolador de LIFO síncrona

bibliotecas de bloquesbibliotecas de bloques prediseñados prediseñados (v) (v)

Foundation Library: MemoryDW_asymfifo_s1_df DW_asymfifo_s1_sfDW03_fifo_a_dfDW03_fifo_a_sfDW_fifo_s1_dfDW_fifo_s1_sfDW_fifo_s2_sfDW_asymfifoctl_s1_dfDW_asymfifoctl_s1_sfDW03_fifocntl_a_dfDW03_fifocntl_a_sfDW_fifoctl_s1_dfDW_fifoctl_s1_sfDW_fifoctl_s2_sfDW_llfifocntl_s1_df

DW_stackDW_stackctl

cola

spi

las

105


bibliotecas de bloquesbibliotecas de bloques prediseñados prediseñados (vi) (vi)

Foundation Library: Application Specific

filtro FIRfiltro FIR multiciclo

DSP LibraryDW07_fir100DW07_fir110

generador/chequeador CRC de 32-Bitcorrector/chequeador de erroresgenerador/chequeador de paridad

depurador ASCII on-chip

controlador TAPcelda para Boundary Scan Cell tipo BC_1celda para Boundary Scan Cell tipo BC_2celda para Boundary Scan Cell tipo BC_3celda para Boundary Scan Cell tipo BC_4celda para Boundary Scan Cell tipo BC_5celda para Boundary Scan Cell tipo BC_7

DW04_crc32DW_eccDW04_par_gen

DW_debugger

DW_tapDW_bc_1DW_bc_2DW_bc_3DW_bc_4DW_bc_5DW_bc_7

JTA

G

integridadde datos

interfaces

106


bibliotecas de bloquesbibliotecas de bloques prediseñados prediseñados ( (viivii))

inversorbuffer no inversorpuerta and de 2 entradaspuerta and de 3 entradaspuerta and de 4 entradaspuerta and de 5 entradaspuerta and de 8 entradaspuerta nand de 2 entradaspuerta nand de 3 entradaspuerta nand de 4 entradaspuerta nand de 5 entradaspuerta nand de 8 entradaspuerta or de 2 entradaspuerta or de 3 entradaspuerta or de 4 entradaspuerta or de 5 entradaspuerta or de 8 entradaspuerta nor de 2 entradaspuerta nor de 3 entradaspuerta nor de 4 entradaspuerta nor de 5 entradaspuerta nor de 8 entradaspuerta xor de 2 entradaspuerta xor de 3 entradaspuerta xor de 4 entradaspuerta xnor de 2 entradaspuerta xnor de 3 entradaspuerta xnor de 4 entradas

GTECH_NOTGTECH_BUFGTECH_AND2GTECH_AND3GTECH_AND4GTECH_AND5GTECH_AND8GTECH_NAND2GTECH_NAND3GTECH_NAND4GTECH_NAND5GTECH_NAND8GTECH_OR2GTECH_OR3GTECH_OR4GTECH_OR5GTECH_OR8GTECH_NOR2GTECH_NOR3GTECH_NOR4GTECH_NOR5GTECH_NOR8GTECH_XOR2GTECH_XOR3GTECH_XOR4GTECH_XNOR2GTECH_XNOR3GTECH_XNOR4

biestable tipo Dbiestable tipo D de 4 bitsbiestable tipo D de 8 bitsbiestable de scan tipo Dbiestable tipo D con clearbiestable tipo D de 4 bits con clearbiestable tipo D de 8 bits con clearbiestable de scan tipo D con clearbiestable tipo D con clear y setbiestable tipo D de 4 bits con clear y setbiestable tipo D de 8 bits con clear y setbiestable de scan tipo D de 4 bits con clear y setbiestable tipo D con setbiestable tipo D de 4 bits con setbiestable tipo D de 8 bits con setbiestable de scan tipo D con setbiestable tipo JKbiestable de scan tipo JKbiestable tipo JK con clearbiestable de scan tipo JKbiestable tipo JK con clear y setbiestable de scan tipo JK con clear y setlatch tipo Dlatch tipo D activo a bajalatch tipo D activo a baja con salida únicalatch tipo D con clearlatch tipo D activo a baja con clearlatch tipo D activo a baja con salida única y clearlatch tipo SRuno lógicocero lógico

GTECH_FD1GTECH_FD14 GTECH_FD18 GTECH_FD1S GTECH_FD2GTECH_FD24GTECH_FD28GTECH_FD2SGTECH_FD3GTECH_FD34GTECH_FD38GTECH_FD3SGTECH_FD4GTECH_FD44GTECH_FD48GTECH_FD4SGTECH_FJK1GTECH_FJK1SGTECH_FJK2GTECH_FJK2SGTECH_FJK3GTECH_FJK3SGTECH_LD1GTECH_LD2GTECH_LD2_1GTECH_LD3GTECH_LD4GTECH_LD4_1GTECH_LSR0GTECH_ONE GTECH_ZERO

GTECH Library

107


bibliotecas de bloquesbibliotecas de bloques prediseñados prediseñados ( (viiiviii))

GTECH_AND_NOTGTECH_OR_NOTGTECH_AO21GTECH_OA21GTECH_AO22GTECH_OA22GTECH_AOI21GTECH_OAI21GTECH_AOI22GTECH_OAI22GTECH_AOI222GTECH_AOI2N2GTECH_OAI2N2GTECH_MAJ23GTECH_MUX2GTECH_MUXI2GTECH_MUX4GTECH_MUX8GTECH_ADD_ABGTECH_ADD_ABCGTECH_TBUFGTECH_INBUFGTECH_OUTBUFGTECH_INOUTBUF

puerta and de 2 entradas invertidaspuerta or de 2 entradas invertidas1 puerta and de 2 entradas que estimulando a 1 puerta or de 2 entradas1 puerta or de 2 entradas que estimula a 1 puerta and de 2 entradas2 puertas and de 2 entradas que estimulan a 1 puerta or de 2 entradas2 puertas or de 2 entradas que estimulan a 1 puerta and de 2 entradas1 puerta and de 2 entradas que estimula a 1 puerta nor de 2 entradas1 puerta or de 2 entradas que estimula a 1 puerta nand de 2 entradas2 puertas and de 2 entradas que estimulan a 1 puerta nor de 2 entradas2 puertas or de 2 entradas que estimulan a 1 puerta nand de 2 entradas3 puertas and de 2 entradas que estimulan a 1 puerta nor de 3 entradas1 puerta and de 2 entradas y 1 puerta nor de 2 entradas que estimulan a 1 puerta nor de 2 entradas1 puerta or de 2 entradas y 1 puerta nand de 2 entradas que estimulan a 1 puerta nand de 2 entradasfunción mayoría 2 de 3multiplexor 2 a 1multiplexor 2 a 1 invertido multiplixor 4 a 1multiplexor 8 a 1semisumadorsumador completobuffer triestado no inversorbuffer de entradabuffer de salidabuffer de entrada/salida

GTECH Library (cont.)

108


bibliotecas de bloquesbibliotecas de bloques prediseñados prediseñados (x): uso (x): uso

library IEEE,DW02;use IEEE.std_logic_1164.all;use IEEE.std_logic_arith.all;use DW02.DW02_components.all;

entity divisorDW is generic( wordlength1 : integer := 8; wordlength2 : integer := 4 ); port( dividendo : in std_logic_vector( wordlength1–1 downto 0 ); divisor : in std_logic_vector( wordlength2–1 downto 0 ); cociente : out std_logic_vector( wordlength1–1 downto 0 );end divisorDW;

architecture operador of divisorDW isbegin cociente <= std_logic_vector( unsigned( dividendo ) / unsigned( divisor ) );end operador;

architecture funcion of divisorDW isbegin cociente <= std_logic_vector( DW_divide( unsigned( dividendo ), unsigned( divisor ) ) ); end funcion;

architecture instancia of divisorDW is signal zero : std_logic;beginzero <= ‘0’;U1 : DW02_divide generic map ( A_width=>wordlength1, B_width=>wordlenght2, TC_mode=>0 ) port map ( A=>dividendo, B=>divisor, TC=>zero, DIVIDE_BY_0=>open, QUOTIENT=>cociente );end instancia;

109


directivas dedirectivas de Synopsys Synopsys: atributos: atributos

attribute ARRIVAL : real;attribute RISE_ARRIVAL : real;attribute FALL_ARRIVAL : real;attribute MAX_RISE_ARRIVAL : real;attribute MIN_RISE_ARRIVAL : real;attribute MAX_FALL_ARRIVAL : real;attribute MIN_FALL_ARRIVAL : real:attribute DRIVE : real;attribute FALL_DRIVE : real;attribute RISE_DRIVE : real;attribute EQUAL : boolean;attribute OPPOSITE : boolean;attribute LOGIC_ONE : boolean;attribute LOGIC_ZERO : boolean;attribute DONT_TOUCH_NETWORK : boolean;

Caracterización de puertos de entrada

attribute LOAD : real;attribute UNCONNECTED : boolean;

Caracterización de puertos de salida

attribute DONT_TOUCH : boolean;

Ligaduras para la síntesisde componentes

Ligaduras de diseñoattribute MAX_AREA : real;attribute MAX_TRANSITION : real;

attribute MAX_DELAY : real;attribute MAX_FALL_DELAY : real;attribute MAX_RISE_DELAY : real;attribute MIN_DELAY : real;attribute MIN_FALL_DELAY : real;attribute MIN_RISE_DELAY : real;

Ligaduras de temporizaciónde puertos de salida

⌦ Tanto la caracterización parcial del entorno de funcionamiento del circuito, como algunasligaduras del proceso de síntesis pueden especificarse mediante atributos definidos porSynopsys en el paquete attributes, biblioteca synopsys.

⌦ Todos estos atributos tienen un comando equivalente en el Design Compiler.

110


directivas deldirectivas del Synopsys Synopsys:: pragmaspragmas

⌦ Las directivas son comentarios VHDL que tienen un significado especial para laherramienta de síntesis, con ellas se puede:Ø Controlar desde el código fuente el modo en que se interpretan las construcciones VHDL.

Ø Insertar comandos no ejecutivos (inserción de atributos o ligaduras) que el Design Compilerejecutará tras leer el código VHDL., con algunas restricciones:

ü No pueden utilizarse ni en paquetes ni en funciones

ü Si se ubican fuera de una unidad de diseño los comandos se aplican a todas lasunidades contenidas en el fichero.

ü Si se ubican dentro de una unidad de diseño los comandos se aplican sólo a esa.

⌦ Las directivas comienzan por synopsys o pragma (tras los dos guiones).

-- synopsys resolution_method wired_and-- synopsys resolution_method wired_or-- synopsys resolution_method three_state

-- synopsys map_to_entity entidad-- synopsys return_port_name nombre_puerto-- synopsys built_in

-- pragma dc_script_begin-- comandos-- pragma dc_script_end

Translación de código-- synopsys synthesis_off-- synopsys synthesis_on-- synopsys translate_on-- synopsys translate_off

Implementación de f. de resolución

Proyección de funciones

Scripts empotrados

111


directivas de directivas de SynopsysSynopsys: uso: uso

library IEEE;use IEEE.std_logic_1164.all;

package rtModules is function mux( x0, x1, sel: in std_logic_vector ) return std_logic;end rtModules;

package body rtModules is function mux( x0, x1, sel: in std_logic ) return std_logic is -- pragma map_to_entity MUX21 -- pragma map_only -- pragma return_port_name Z begin if sel=‘1’ then return x1; else return x0; end if; end;end rtModules;

· 1 vhdl’87 – subconjunto sintetizable* *para synospys vhdl compiler diseño automático de...

Documents