lenguaje vhdl microelectronica

VHDL- I. Microelectrónica. Curso 01/02

Carlos Medrano, E.U. Politécnica de Teruel - 1 -

LENGUAJE VHDL

1. Introducción. ................................................................................................................................................. 2

2. Elementos sintácticos en VHDL................................................................................................................... 3

3. Formas de descripción en VHDL. ............................................................................................................... 73.1. Descripción mediante flujos de datos. ..................................................................................................... 83.2. Descripción comportamental algorítmica. ............................................................................................. 103.3. Descripción estructural. ......................................................................................................................... 15

4. Poniendo orden: subprogramas, paquetes y bibliotecas.......................................................................... 194.1. Funciones y procedimientos................................................................................................................... 194.2. Bibliotecas, paquetes y unidades. .......................................................................................................... 21

5. Ejemplos de VHDL. .................................................................................................................................... 235.1. Flip-flop D síncrono............................................................................................................................... 245.2. F-F tipo D con puesta a cero y a uno asíncronas.................................................................................... 245.3. Contadores. ............................................................................................................................................ 255.4. Máquinas de estado................................................................................................................................ 265.5. Salidas triestado. .................................................................................................................................... 275.6. Puertos bidireccionales. ......................................................................................................................... 27

Bibliografía...................................................................................................................................................... 28



1. Introducción.

Con la creciente complejidad de los diseños digitales ha aparecido una necesidad de describir uncircuito de la forma más eficiente y práctica posible. Un lenguaje de programación ofrece laposibilidad de un alto nivel de abstracción y es la solución adecuada para dicha tarea. Entre loslenguajes para la descripción de circuitos digitales, el VHDL es el que está alcanzando mayorpopularidad, por ser un estándar y por su amplio campo de aplicación, desde el modelado para lasimulación de circuitos, hasta la síntesis automática de circuitos.

El significado de las siglas VHDL es Very high speed integrated circuit (VHSIC) HardwareDescription Language. VHDL es una forma en que los humanos y las máquinas puedan leer yentender la funcionalidad y la organización de sistemas hardware digitales. Las ventajas del VHDLson:

-Permite diseñar y modelar un sistema en varios niveles de abstracción: flujo de datos,estructural, algorítmico.

-Una descripción en VHDL es independiente de la implementación hardware final del proyecto.Puede ser sintetizado sobre una PLD o un ASIC. Incluso puede servir para simulaciónexclusivamente.

-Permite el diseño Top-Down y modular, es decir, dividir un sistema complicado en subsistemasmás sencillos, tantas veces como sea necesario hasta poder resolver cada módulo (subsistema) porseparado. Ello facilita la prueba de cada módulo independientemente y da más seguridad al correctofuncionamiento del sistema final. VHDL ofrece sus propias maneras de definir "subprogramas".

-Es un estándar (IEEE Std 1076-1987, IEEE Std 1076-1993). No obstante, hay que decir quecada fabricante ofrece sus propias librerías con funciones útiles no definidas en el estándar. Por ello,el paso de un entorno de programación a otro no es trivial. Nosotros suponemos que trabajamos conel estándar del año 93.

Inicialmente, VHDL fue diseñado para el modelado de circuitos digitales. Su utilización ensíntesis (implementación hardware) no es inmediata, aunque la sofisticación de las actualesherramientas es tal que permite implementar diseños en un alto nivel de abstracción.

En este curso, se explicarán los fundamentos del VHDL pensando en su utilización paraprogramar dispositivos de tipo PLD o FPGA. No conviene olvidar que el VHDL en sí mismo noestá asociado a dispositivos programables, sino que es una descripción de un circuito en alto nivel.De cualquier modo, una descripción que sea sintetizable es casi siempre válida también parasimulación, mientras que una descripción para simulación puede tener más problemas a la hora decompilarla sobre un dispositivo hardware.

En este capítulo se introducen mediante ejemplos, la sintaxis del lenguaje, de forma que secubran los bloques más habituales en diseño digital, intentando que rápidamente sea posible escribirprogramas útiles, por comparación con los ejemplos dados en los apuntes. No pretende ser una guíaextensa del VHDL. Para ello, y para resolver problemas concretos, es necesario acudir a labibliografía o a los manuales que cada fabricante ofrece.

La herramienta que usaremos se denomina MaxPlusII, de la marca Altera. Es un programa queadmite entradas en VHDL, síntesis en PLD de dicha marca, así como simulación de los ficherosfuente para programar las PLD (ficheros jedec, .jed o .pof). Es una herramienta muy potente, quetiene además entrada con captura esquemática, analizador de tiempos y posibilidad de interface con



herramientas de otras marcas. Se puede conseguir una versión gratis (de estudiante) enwww.altera.com, que aunque obviamente no tiene todas las posibilidades de la herramientacompleta, permite el contacto con un entorno profesional.

2. Elementos sintácticos en VHDL.

Daremos unas breves definiciones de los elementos que se usan en VHDL

Comentarios: empiezan por dos guiones "--" seguidos, hasta el final de línea.

Símbolos especiales: de un sólo carácter + - / * ( ) . , : ; & ' " < > | = #de dos caracteres ** => := /= >= <= <> --

Identificadores: Se usan para dar nombre a los diferentes objetos del lenguaje. Pueden sercualquier nombre compuesto por letras y números, incluyendo el símbolo de subrayado "_". Nuncapuede contener uno de los símbolos especiales, no puede empezar por un número ni contener dossubrayados seguidos. Las mayúsculas y minúsculas se consideran iguales. Tampoco puede coincidircon una de las palabras reservadas del lenguaje (que tienen un significado predefinido).

Números: Se considera que están en base 10. Se admite la notación científica para números encoma flotante. Es posible escribir números en otras bases utilizando el símbolo #. Así,2#11000100# es un número en base 2, 16#c4# en hexadecimal. No obstante, los números sonmucho menos utilizados en VHDL que en otros lenguajes de programación, puesto que es unlenguaje orientado a diseños digitales, donde los valores que se manejan son bits o cadenas de bits.

Caracteres: Cualquier letra o número entre comillas simples: '2', 't'.

Cadenas: Conjunto de caracteres en comillas dobles: "hola"

Cadenas de bits: los bits son en realidad caracteres, y es posible formar con ellos cadenas yrepresentar números. "1110100", O"126", X"FE"; el primero es binario, el segundo octal, indicadopor la O delante de la cadena, el último es hexadecimal, indicado por la X delante de la cadena.

Palabras reservadas. Son aquellas que tienen un significado especial en VHDL

Operadores.

& concatenación. Concatena cadenas: así "110" & "001" representa "110001".

** exponencial 4**2 representa 4 al cuadrado<= := de asignación, el primero para señales, el segundo para constantes y variables.ABS() valor absoluto* multiplicación/ divisiónMOD (módulo)REM (resto)

SLL, SRL Desplaza un vector de bits un número de bits a la izquierda o a la derecha, rellenandocon ceros los huecos libres



SLA, SRA Como el anterior pero el desplazamiento conserva el signo, el valor del bit mássignificativo.

ROL, ROR rotación a izquierda o a derecha. Como un desplazamiento, pero los huecos que seforman son ocupados por los bits que van saliendo.

=, /= igualdad o desigualdad<, <=, >, >= menor, menor o igual, mayor, mayor o igualNot, and, nand, or, nor, xor, xnor.

Tipos de datos.

La sintaxis de VHDL es estricta con respecto a los tipos. Cualquier objeto que se defina debetener un tipo. En VHDL no existen tipos propios del lenguaje, pero existen los mecanismos parapoder definir cualquier tipo. Las librerías que se declaran al principio del programa incluyen lostipos más habituales.

Tipos escalares: Son tipos simples. Tienen un orden que permite usar operadoresrelacionales con ellos. Pueden ser enumerados, enteros, flotantes y físicos.

Enteros: Se definen incluyendo el rango.

type index is range 7 downto 1;type integer is range –2147483648 to 2147483647; -- tipo predefinido

Reales (coma flotante): Se deben definir también en un rango, pero con límites reales.Físicos: Datos que trabajan con magnitudes físicas, es decir, con valor y unidades. Hay un tipo

predefinido en VHDL que es el tiempo, time.

Enumerados: Pueden tomar cualquier valor en una lista.

type bit is ('0','1'); --Predefinidotype boolean is (FALSE, TRUE); -- Predefinido

El estandar IEEE 1164 define un tipo enumerado adicional, std_ulogic, y varios subtipos. El tipostd_ulogic se define con una lista de 9 posibilidades:

type std_ulogic is ('U', -- Sin inicializar 'X', -- Fuerza a desconocido

'0', -- fuerza a 0'1', -- fuerza a 1'Z', -- Alta impedancia'W', -- Desconocido débil'L', -- 0 débil'H', -- 1 débil'-', -- no importa);

El subtipo std_logic proviene del std_ulogic y la lista de valores es la misma, pero este subtipotiene una función de resolución (concepto en el que no entraremos). En la práctica, nosotrosusaremos muy a menudo el tipo std_logic para síntesis. Es más amplio que el tipo bit, al incluir losestados de alta impedancia y de no importa. Para usar el subtipo std_logic hay que incluir el paquetestd_logic_1164 de la librería ieee.



Tipos compuestos. Están compuestos por tipos escalares.

Matrices: Colección de elementos a los que se accede mediante un índice.

type word is array(31 downto 0) of bit;signal b: word;

A los elementos de una matriz se accede mediante los índices. Si dato es una señal de tipo word,dato(3) es el elemento 3 de dato, dato(29 downto 25) es una parte del array.

Existen algunos tipos predefinidos.

type bit_vector is array (natural range <>) of bit;type std_logic_vector is array (natural range <>) of std_logic;

que nos permiten definir señales como:

signal a: std_logic_vector(3 downto 0);

Son también de gran importancia los tipos unsigned y signed. Representan vectores de std_logicpero considerándolos con signo. El tipo unsigned representa valores numéricos positivos o cero. Eltipo signed representa valores tanto negativos como positivos en complemento a 2. Esto tiene unaimplicación a la hora de hacer comparaciones y otras operaciones.

signal a: unsigned(3 downto 0);

Registros: Equivalente al tipo record de otros lenguajes.

Subtipos.

Es posible la definición de subtipos como subconjuntos de tipos existentes.

subtype raro is integer range 4 to 7;subtype id is string(1 to 20);

Atributos.

Los elementos en VHDL pueden tener información adicional basada en atributos. Estos atributosestán asociados a ciertos elementos del lenguaje y se manejan mediante la comilla simple '.

Por ejemplo, si t es una señal de un tipo enumerado, entero, flotante o físico, se tienen lossiguientes atributos:

t'left límite izquierdo del tipo leftt'rightt'low menor de los valores en tt'hight'length da el número de elementos de t.



Un atributo importante es 'event. Da un valor booleano verdadero si acaba de ocurrir un cambioen la señal. Se usa especialmente con señales que sean de reloj:

clk'event

Otro atributo que aparece con frecuencia es 'range. Da el rango de un objeto limitado. Porejemplo, si definimos

signal word: std_logic_vector(15 downto 0);

entonces word'range es 15 downto 0

En ciertos programas informáticos, hay también atributos que permiten agregar informaciónadicional a los objetos que se están definiendo en VHDL. Estas informaciones adicionales sirvenpara pasar información a las herramientas de diseño que se estén utilizando en VHDL, por ejemplosi queremos que ciertas señales estén en determinados pines de una PLD. En MaxPlusII se realizade forma gráfica.

Señales, constantes y variables.

Constantes.Una constante es un elemento que se inicializa a un determinado valor que no puede ser

cambiado:

constant indice: integer:=5;constant max_size: integer;

En el segundo caso max_size no tiene ningún valor asociado. Esto se permite siempre y cuandoel valor sea declarado en algún otro sitio.

Variables.Su valor puede ser alterado en cualquier instante. Es posible asignarle un valor inicial:

variable contador: natural:=0;variable aux: bit_vector(31 downto 0);

Las variables sólo tiene sentido en bloques donde la ejecución es en serie: subprogramas yprocesos (process).

Señales.La señal no es un objeto del lenguaje que guarda un valor, sino que lo que hace es guardar un

valor y hacerlo visible en el momento adecuado. Esto es, se puede decir que la señal tiene dospartes, una donde ese escribe y que almacena el valor, y otra que se lee y que no tiene por quécoincidir con lo que se acaba de escribir.

Desde un punto de vista más cercano al mundo de los circuitos digitales, una señal se entenderíacomo un nodo en el circuito (nodo en el mismo sentido que en SPICE). Las entradas y salidas de unbloque digital deben ser definidas como señales. Asimismo, cualquier posible conexión real en elcircuito debe ser definida como señal.

Las asignaciones de señales se realizan con el operador "<=", mientras que las de constantes yvariables utilizan el operador ":=".

Entidades y arquitecturas.



La descripción de un circuito en VHDL consta al menos de dos elementos: la entidad y laarquitectura. En la entidad se definen las señales de entrada y salida. En la arquitectura, se define loque hace el circuito. Previamente a la definición de ambas, se pueden incluir las librerías y lospaquetes necesarios en el programa. Veamos un ejemplo.

library ieee;use ieee.std_logic_1164.all;

entity MUX2to1_a is port(A, B: in std_logic;Sel: in std_logic;Y: out std_logic);end MUX2to1_a;

architecture behavior of MUX2to1_a isbeginY<= ( B and Sel ) or( A and not(Sel) );end behavior;

Las dos primeras líneas del programa contienen las librerías (ieee) y los paquetes(std_logic_1164.all) que serán utilizados en el programa. Los tipos más habituales están declaradosen esta librería, por lo que su uso es casi imprescindible. Como en el programa se usa el tipostd_logic, es necesario incluir este paquete.

En la entidad llamada MUX2to1_a, definimos las salidas (Y) y las entradas del sistema (A,B ySel). Estas señales son puertos (port). Todas ellas están definidas como de tipo std_logic. En estecaso, se trata de un multiplexor de dos canales. En la arquitectura, se define lo que realiza laentidad. En este caso, la descripción son unas simples ecuaciones booleanas.

Los puertos de las entidades se definen con un modo. Los modos pueden ser de 4 clases: in, out,buffer, inout:

- in. Entrada a la entidad.- out. Salidas de la entidad. Este tipo de puertos no se considera legible dentro de la entidad (por

ejemplo, no puede aparecer a la derecha en una asignación)- buffer. Es como el modo out, pero es legible dentro de la entidad. Dicho de otro modo,

permite la realimentación de la señal en la arquitectura.- inout. Para señales bidireccionales, se tiene que declarar el puerto como inout, que permite que

se pueda escribir o leer desde el exterior.

3. Formas de descripción en VHDL.

En VHDL existen dos aproximaciones a la descripción comportamental de un circuito. Por unlado, se pueden especificar las ecuaciones de transferencia entre diferentes objetos en VHDL. Estaposibilidad de descripción de un circuito se llama descripción de flujo de datos, o RTL (registertransfer level). La otra forma de describir circuitos en un nivel de abstracción todavía más elevadose conoce como descripción comportamental o algorítmica. Esta segunda posibilidad incluye a laprimera y permite al diseñador de circuitos describir la funcionalidad en un nivel alto deabstracción.



La diferencia más importante entre un estilo de descripción y el otro es que la ejecución ointerpretación de sentencias en flujos de datos es concurrente, es decir, las sentencias indicanconexiones o leyes que se cumplen, por tanto es como si se ejecutaran continuamente. Esta es unadiferencia clara con otros lenguajes como el C, Pascal, Fortran etc., donde la ejecución de lassentencias es en serie. Esto último significa que las sentencias son ejecutadas una tras otra por elordenador.

Lenguajes como VHDL, pensado para describir circuitos, deben ser ante todo concurrentes. Uncircuito no se ejecuta en serie, sino que las conexiones entre componentes siempre actúan. Noobstante, el lenguaje VHDL también permite descripciones con ejecución en serie, que hacen másfácil la programación en abstracto.

3.1. Descripción mediante flujos de datos.

when ... else

Se trata de una estructura concurrente. Veamos el ejemplo de un decodificador BCD a 10 líneas:


entity BCD_9 is port(A: in std_logic_vector(3 downto 0);Y: out std_logic_vector(9 downto 0));

end BCD_9;

architecture archBCD_9 of BCD_9 isbegin

Y<="0000000001" when A="0000" else "0000000010" when A="0001" else "0000000100" when A="0010" else "0000001000" when A="0011" else "0000010000" when A="0100" else "0000100000" when A="0101" else "0001000000" when A="0110" else "0010000000" when A="0111" else "0100000000" when A="1000" else "1000000000" when A="1001" else "0000000000";

end archBCD_9;

En este caso, usamos varios when ... else anidados. Cuando la entrada A toma un número enBCD, la línea correspondiente se activa.

¿Qué significa en este caso que la estructura es concurrente? Por ejemplo, es imposible asignarotros valores a la salida Y en el mismo programa. Así, este otro código daría un error decompilación:

-- Incorrectolibrary ieee;use ieee.std_logic_1164.all;




end BCD_9;


Y<="0000000001" when A="0000" else "0000000010" when A="0001" else "0000000100" when A="0010" else "0000001000" when A="0011" else "0000010000" when A="0100" else "0000100000" when A="0101" else "0001000000" when A="0110" else "0010000000" when A="0111" else "0100000000" when A="1000" else "1000000000" when A="1001" else "0000000000";

Y<="1111111110" when A="0000" else "1111111101" when A="0001" else "1111111011" when A="0010" else "1111110111" when A="0011" else "1111101111" when A="0100" else "1111011111" when A="0101" else "1110111111" when A="0110" else "1101111111" when A="0111" else "1011111111" when A="1000" else "0111111111" when A="1001" else "1111111111";end archBCD_9;

Aquí hemos escrito dos decodificadores distintos, uno escrito después del otro. Es un errorpensar que, puesto que el segundo bloque está después del primero, es la activación en baja de laslíneas la que se va a ejecutar. Este programa no puede compilarse. En Pascal por ejemplo, no hayningún problema en dar dos valores distintos a las variables, quedándose con el último. En realidad,lo que estoy haciendo es, pensando en un circuito, conectar las salidas de dos decodificadoresdistintos al mismo punto (Y(9), Y(8) etc.). Por tanto, ¿qué ocurre cuando los dos decodificadoresmanden señales distintas a las salidas? Esta incompatibilidad es la impide la compilación. (Siendoestrictos, el VHDL permite este tipo de situaciones si se incluye un mecanismo de resolución de lasseñales, que indica qué ocurre en caso de incompatibilidad; éste es un concepto de VHDLavanzado, que no veremos). Esto es válido para cualquier estructura concurrente.

Conviene también fijarse es la definición de un vector de tipo std_logic. Por ejemplo, A sedefine como un std_logic_vector(3 downto 0). Hay que tener en cuenta que en este caso, el bit mása la izquierda corresponde al de índice 3, mientras que si se hubiese definido comostd_logic_vector(0 to 3), sería el de índice 0. Esto es importante, puesto que en operacionesaritméticas con cadenas de bits, el bit más a la izquierda es el más significativo.

with ... select ... when

Es también una estructura concurrente. El codificador BCD a 10 líneas queda:





end BCD_9;


with A select Y<="0000000001" when "0000", "0000000010" when "0001",

"0000000100" when "0010","0000001000" when "0011","0000010000" when "0100","0000100000" when "0101","0001000000" when "0110","0010000000" when "0111","0100000000" when "1000","1000000000" when "1001","0000000000" when others;

end archBCD_9;

Según el valor de la señal A, se produce una asignación u otra. Es importante la última línea,when others. Si no hemos agotado todas las posibilidades de la entrada A, es necesaria esta últimalínea para indicar qué debe hacerse en los casos que no se pongan de forma explícita anteriormente.En la práctica, es casi obligatorio ponerlo. No conviene olvidar que al definir A como un tipostd_logic_vector(3 downto 0), no sólo hay 16 posibilidades para A, sino que el resto de valoresposibles para A también cuentan, por ejemplo "ZZZZ", o "----". Por ello, incluso un decodificadorde 4 a 16 líneas necesitaría when others al final, puesto que se ha definido la entrada A como detipo std_logic_vector.

3.2. Descripción comportamental algorítmica.

Se trata de partes del programa con una ejecución en serie, definidos dentro de unidades quecomienzan con la palabra clave process. En un mismo programa puede haber múltiples bloquesprocess. Cada uno de ellos equivale a una instrucción concurrente. Es decir, aunque internamente elproceso describe el comportamiento de un circuito mediante una ejecución de instrucciones enserie, el compilador para síntesis deduce un circuito a partir de un proceso, y por tanto esconcurrente con el resto de las instrucciones (no puedo asignar un valor a una señal dentro y fuerade un proceso).

process: if ... then


entity and3 is port(a,b,c: in std_logic;y: out std_logic);

end and3;

architecture archand3 of and3 isbegin



p1: process (a,b,c)begin if (a='1' and b='1' and c='1') then y<='1'; else y<='0'; end if;end process;end archand3;

El proceso contiene un identificador, p1 (el nombre que queramos). Posee además una"sensitivity list" o lista sensible, (a,b,c), que indica que el proceso se ejecutará cuando haya uncambio en una de estas variables. Como en cualquier ejecución en serie, hay que tener cuidado alanidar los if-then, de forma que el resultado sea el esperado. La utilización de else es opcional, perosi no se agotan todas las opciones, puede dar lugar a latches. Cuando se utilizan varios if thenanidados, puede usarse una contracción de else if, elsif. En caso de usar la primera forma, esnecesario cerrar el nuevo if que se crea. En caso de usar la forma contraída, no hay que cerrarningún if adicional. Si la condición que se ha de cumplir se refiere a la detección de un flanco dereloj y va precedida de otro if previo, es necesario usar elsif en la detección del flanco de reloj, porejemplo, en un contador con reset asíncrono, la condición de detección del reset va antes de ladetección de flanco de reloj.

Es conveniente dejar claro en el código qué es lo que tiene que asignarse a las señales de salidaen el proceso para todas las posibilidades de las señales en la lista sensible. En caso de que hayacasos no especificados al anidar los if, el compilador guarda el valor anterior de la señal encuestión, es decir se trata de un latch.

La forma en que un proceso se evalúa puede ser entendida del siguiente modo. Cuando una señalque se encuentra en la "sensitivity list" del proceso cambia, este es ejecutado de forma secuencial.Una vez que se ha llegado a la última instrucción, el proceso se detiene y las señales se actualizan.Es decir, se puede imaginar como los valores antes y después de un paso de simulación.

Desde el punto de vista de la síntesis, en el proceso se determinará el valor de una o variasseñales, en función de otras que deben estar todas en la lista sensible. El compilador deducirá elcircuito lógico que dé el mismo comportamiento que el conjunto de las sentencias secuenciales delproceso (con la distinción entre variables y señales que veremos luego). Una vez obtenido elcircuito lógico, éste es concurrente con respecto al resto de construcciones dentro de la arquitectura.El siguiente programa por ejemplo, es un error.


entity and3 is port(a,b,c: in std_logic;y: out std_logic);

end and3;

architecture archand3 of and3 isbegin

p1: process (a,b,c)begin if (a='1' and b='1' and c='1') then y<='1'; else y<='0'; end if;end process;



y<= a or b or c;end archand3;

Diferencias entre variables y señales.

Es muy importante distinguir entre variables y señales dentro de un proceso. Las señales nocambian su valor hasta que no acaba el proceso. Las variables sólo se definen dentro del proceso, (o dentro de bloques de ejecución en serie, como funciones y procedimientos) y cambian su valor enel momento en el que tienen una asignación.

Por ejemplo, consideremos estos dos procesos:

architecture ejemp1 of entidad issignal a,b,c,x,y: integer;beginp1: process(a,b,c)begin c<=a; -- se ignora x<=c+2; c<=b; y<=c+2;end process p1;end ejemp1;

architecture ejemp1 of entidad issignal a,b,x,y: integer;begin p1: process (a,b) variable c: integer; begin c:=a; -- Inmediata x<=c+2; c:=b; -- Inmediata y<=c+2;end process p1;end ejemp1;

En el código de la izquierda sólo se usan señales y la ejecución tiene lugar de la siguientemanera: En primer lugar se hace la fuente de "c" igual a "a", lo cual sólo indica que tomará esevalor en el próximo paso de simulación (al salir del proceso), pero no en el presente. A continuaciónse hace lo mismo con "x", asignándole a su fuente el valor de "c+2", es decir el valor que contuviera"c" antes de empezar la ejecución, porque el valor que se le asignó en el paso anterior todavía noestá presente. Luego, se hace "c<=b", es decir que se está sustituyendo el valor de la fuente de "c",que era "a", por la señal "b". Esto quiere decir que el futuro valor de "c" ya no será "a", sino "b". Acontinuación se hace "y<=c+2", de manera que a "y" se le asigna el valor "c+2", pero tomandocomo "c" el valor de la señal antes de empezar el proceso.

En definitiva, supongamos que antes de iniciarse la ejecución se tiene "c=2", "a=4", y "b=6".Entonces al final de la ejecución de este proceso se tendrá "c=b=6", "x=4", "y=4". De todas formas,puesto que la señal "c" ha cambiado y, como se encuentra en la lista sensible, el proceso se vuelve aejecutar, quedando finalmente "c=b=6", "x=y=8".

Se ha visto que la primera instrucción "c<=a" es ignorada completamente en la práctica. Esto esdebido a que las señales no se asignan inmediatamente y a que existe una sentencia posterior"c<=b" que escribe sobre "c".

En el programa de la derecha "c" es una variable. La definición de esta variable se hace dentrodel proceso, puesto que sólo tiene sentido dentro de la ejecución serie. También "c" desaparece dela lista sensible puesto que las variables son internas a los procesos (o a los subprogramas) y nuncapueden formar parte de las listas sensibles.



La ejecución es muy simple. Primero "c" toma el valor de "a", "c:=a". Hay que hacer notar elsímbolo de asignación ":=" para variables. Como "c" es una variable, "c" toma el valor 4 justo eneste momento. A continuación se hace la fuente de "x" igual a "c+2", es decir "x" tomará el valor 6el próximo paso de simulación. A continuación se hace "c:=b", de manera que ahora "c" vale 6.Después viene "y<=c+2", por lo que "y" valdrá 8 cuando se acabe la ejecución. Al finalizar elprocess se tiene que "x=6" e "y=8", y no se volverá a ejecutar puesto que ni "a" ni "b" hancambiado.

Esta discusión sobre variables y señales es válida en cualquier proceso "process".

En la práctica, las variables pueden ser útiles para hacer algunas construcciones, y soninevitables en los índices que recorren los vectores, pero se puede prescindir de su uso en lamayoría de las ocasiones. Un proceso con variables y señales puede ser bastante complicado decomprender. Hay que evitar el uso de

Conviene recordar también que las señales sólo se actualizan al final del proceso. No hay queponer sentencias en el proceso que dependan de una asignación previa a una señal.

process: case .. when

Se trata de una estructura de ejecución en serie. Es parecido al with ... select, pero más general,puesto que en cada caso no sólo se puede hacer una asignación, sino que después de cada "=>"puede escribirse una sentencia o un conjunto de ellas.


entity mux4to1 is port(a: in std_logic_vector(3 downto 0);sel: in std_logic_vector(1 downto 0);y: out std_logic);

end mux4to1;

architecture archmux4to1 of mux4to1 isbegin

p1: process (a,sel)begin

case sel is when "00" => y<=a(0); when "01" => y<=a(1); when "10" => y<=a(2); when "11" => y<=a(3); when others => y<=a(0); end case;

end process;

end archmux4to1;

Como en el caso del with ... select es necesario completar con when others, cuando no se hanrevisado todos los casos posibles.



bucles: process: for y while loop

Permiten realizar bucles dentro de procesos. También se ejecutan en serie.

-- cuatro multiplexores 2 a 1 controlados por la misma entrada-- de seleccion

library ieee; use ieee.std_logic_1164.all;

entity cuatromux2to1 isport(

a: in std_logic_vector(7 downto 0);sel: in std_logic;y: out std_logic_vector(1 to 4));

end cuatromux2to1;

architecture archcuatromux2to1 of cuatromux2to1 is

type lineas is array (1 to 4) of std_logic_vector(1 downto 0);signal dum: lineas;

begin

p1: process (dum,sel)variable i: integer range 1 to 4;-- Al ser un indice de un loop

-- esta definicion es optativabeginfor i in dum'range loop y(i)<= (sel and dum(i)(1)) or (not(sel) and dum(i)(0));end loop;end process;

dum(1)<=a(1 downto 0);dum(2)<=a(3 downto 2);dum(3)<=a(5 downto 4);dum(4)<=a(7 downto 6);

end archcuatromux2to1;

Este programa es poco práctico, sólo se escribe para mostrar, además de los bucles, el uso de losarrays. Hemos definido un array de vectores de std_logic. Es en definitiva una matriz:

type lineas is array (1 to 4) of std_logic_vector(1 downto 0);

Hay que hacer notar también el uso del for loop, así como del atributo 'range. Este atributo da elrango de un objeto. En nuestro caso es de 1 a 4, puesto que hemos definido el tipo lineas como unarray (1 to 4).

La señal dum está definida como de tipo lineas. Entonces dum(1) es el primer elemento delarray. Como cada elemento es un std_logic_vector, dum(1) es un std_logic_vector, y dum(1)(1) essu primer elemento. Una definición alternativa de un array con el mismo número de elementos es:

type lineas is array (1 to 4, 1 downto 0) of std_logic;



En este caso, si dum fuese de tipo lineas, un elemento de dum necesita dos índices, dum(1,0) porejemplo, y cada elemento es un std_logic.

Es interesante también la manera de referirse a una parte de una cadena, en la forma a(7 downto6), que selecciona dos elementos de la cadena total "a", definida como un std_logic_vector(7downto 0). Hacemos hincapié asímismo la definición de señales y de tipos dentro de laarquitectura:

type lineas is array (1 to 4) of std_logic_vector(1 downto 0);signal dum: lineas;

La señal dum no es de salida ni de entrada. Se podría entender como un nodo interno al circuito.

De forma análoga al for ... loop se define el while ... loop. Existe también la posibilidad de salirde los bucles con next y exit. (*) Nota: exit no está soportado por MaxPlusII

3.3. Descripción estructural.

Este tipo de descripción es cercano a una net-list de otras herramientas CAD. La descripciónestructural es especialmente interesante para la incorporación de elementos de biblioteca al diseño yla realización de diseños jerárquicos a partir de componentes. Consideremos dos entidades,and_de_3 y or_de_n:

library ieee;use ieee.std_logic_1164.all;entity and_de_3 is port( a,b,c: in std_logic; y: out std_logic);end and_de_3;architecture archand_de_3 of and_de_3 isbegin y<='1' when a='1' and b='1' and c='1' else '0';end archand_de_3;

-----------------------------------------------------------------------------------------------------------library ieee;use ieee.std_logic_1164.all;entity or_de_n isgeneric(n: integer:=2);port(a: in std_logic_vector(n-1 downto 0);y: out std_logic);end or_de_n;architecture archor_de_n of or_de_n isbeginp1: process(a)variable i: integer range 0 to n-1;variable res_parcial: std_logic;beginres_parcial:='0';bucle:for i in 0 to n-1 loop res_parcial:=res_parcial or a(i);end loop bucle;



y<=res_parcial;end process;end archor_de_n;

Obsérvese que en el segundo caso existe una definición de una entidad con un parámetrovariable, por ello se usa entity ... generic. De esta forma se puede definir una puerta or de nentradas, siendo por defecto de dos entradas.

Cada una de estas entidades se compilaría por separado.

Estas entidades se pueden definir en una librería, con el paquete (package)correspondiente. Estopermite a un programa principal llamar a esos componentes (es decir, otras entidades definidas enlibrerías), asociándoles los puertos correspondientes. Veremos como definir librerías en MaxPlusII.Suponiendo que la librería se llama "milibrería" y que el paquete se llama "puertas", el programaprincipal quedaría:

-- Programa principallibrary ieee;library milibreria;use ieee.std_logic_1164.all;use milibreria.puertas.all;

entity variaspuertas is port(r,s,t,p: in std_logic;y: out std_logic);end variaspuertas;

architecture archvariaspuertas of variaspuertas is

signal x,w,z: std_logic;signal dum1:std_logic_vector(1 downto 0);signal dum2: std_logic_vector(2 downto 0);begin u1: and_de_3 port map(r,s,t,x); dum1<=r & p; u2: or_de_n port map(a=>dum1,y=>z); dum2<=r&s&p; u3: or_de_n generic map(3) port map (dum2,w); y<=x or z or w;end;

La entidad and_de_3 es una puerta and de tres entradas y la segunda or_de_n una puerta or de nentradas, donde n es un parámetro que por defecto es 2. Es interesante el uso de generic antes deport, para permitir que la entidad tenga uno o varios parámetros variables.

En la arquitectura del programa principal se hace una asignación de los "nudos" de cadacomponente. La orden básica es port map:

u1: and_de_3 port map (r,s,t,x);

u1 es un identificador de la sentencia, puede ser cualquier nombre. and_de_3 es el nombre delcomponente. Como en él hemos definido los tres primeros puertos como una entrada, y el últimopuerto como una salida, el hecho de poner el orden (r,s,t,x) implica que x será el resultado de unaoperación AND de r, s y t. Conviene hacer notar que los identificadores r,s,t y x no tienen por quécoincidir con los de la definición del componente (a,b,c,y). La orden port map no admite constantes.



La siguiente orden:

u2: or_de_n port map(a=>dum1,y=>z);

es otra asignación usando el operador "=>", en este caso a una componente or_de_n. Como nohacemos referencia al tamaño (parámetro n), se toma por defecto el definido en la entidad or_de_n,es decir, 2. En el paréntesis, podemos ver otra forma de realizar una asignación, en lugar de porposición como en el ejemplo anterior, mediante el operador =>. Asignamos la señal "dum1" alpuerto llamado "a" de or_de_n, y la señal "z" al puerto "y". "a" e "y" son los nombres de los puertosen el componente, mientras que "dum1" y "z" son los nombres de las señales en el programaprincipal. La señal "dum1" es una señal intermedia, que no es más que la concatenación de "r" y"p". Así obtengo un std_logic_vector, que es compatible con la definición del puerto "a" en lacomponente "or_de_n". Si utilizo esta forma de asignación, no necesito dar las señales en el mismoorden que en la definición del componente.

La siguiente orden:

u3: or_de_n generic map(3) port map (dum2,w);

es una puerta or de 3 entradas. Generic map (3) sirve para pasar el parámetro al componente, eneste caso se le dice que el tamaño del vector de entrada es 3.

Finalmente, la salida final, "y", no se define mediante componentes sino mediante operadoresbooleanos:

y<=x or z or w;

Se puede, por tanto, mezclar tipos de descripciones dentro de un mismo programa, siempre queuna misma señal no sea escrita en distintos puntos del programa.

Las señales dum1 y dum2 sólo sirven para tener una compatibilidad con los tipos definidos enlas componentes. Así, or_de_n admite como entrada un std_logic_vector. Por tanto, debo pasarle unobjeto del mismo tipo.

En resumen, lo que hemos construido es un circuito como este:

x

w

z

y

rst

p

U?

OR2

12

3

U?

OR3

1234

U?

OR3

1234

U?

AND3

1234



Es posible definir también las componentes and_de_3 y or_de_n en un único programa, en lugarde en una librería. En el listado, se comenzaría por las entidades y arquitecturas de cada uno deellos, repitiendo cada vez las librerías que se usen en cada entidad-arquitectura. En la arquitecturaprincipal, se definen las componentes que se van a utilizar, mediante las sentencia component.

component and_de_3 port( a,b,c: in std_logic; y: out std_logic);end component;

Los nombres y los modos de los puertos en estos componentes deben coincidir con los de laentidad definida para cada componente, y deben también colocarse en el mismo orden.

Podemos ver un ejemplo de componente definido en el mismo programa en el siguiente códigoque representa un sumador en serie. Además nos sirve para ilustrar el comando for ... generateusado para hacer varias asignaciones estructurales en un bucle que dependa de un índice:


entity celdasumadora is port( a,b,cin:in std_logic; s, cout: out std_logic);end celdasumadora;

architecture archcelda of celdasumadora isbegin s<=(a xor b) xor cin; cout<= (a and b) or ((a or b) and cin);end archcelda;

-- Programa principal


entity sumador2 is port(a: in std_logic_vector(7 downto 0);b: in std_logic_vector(7 downto 0);cin: in std_logic;sum: out std_logic_vector(7 downto 0);cout: out std_logic);end entity;

architecture archsumador2 of sumador2 issignal c: std_logic_vector(7 downto 0);-- acarreos intermedios

component celdasumadora port( a,b,cin: in std_logic; s, cout: out std_logic);end component;

begin u1: celdasumadora port map(a(0),b(0),cin,sum(0),c(0)); bucle:for i in 1 to 7 generate begin u2: celdasumadora port map(a(i),b(i),c(i-1),sum(i),c(i));



end generate;cout<=c(7);end archsumador2;

Conviene insistir en que esto es un ejemplo para demostrar el funcionamiento de la instruccióncomponent. En este caso, sería mucho más sencillo hacer el programa principal directamente sinnecesidad de definir componentes. La ventaja de component es la capacidad que proporciona alprogramador para hacer un diseño modular, probando cada bloque por separado.

Es posible también definir varias arquitecturas para un mismo componente, y asignar a cadasentencia la arquitectura adecuada en cada caso (sentencia configuration).

ATENCIÓN: En MaxPlusII, existen bastantes problemas a la hora de la compatibilidad de losmodos (in, out, buffer, inout) tal y como se han definido en un componente y el modo de la señalque se coloca en el programa principal. Especialmente problemático resulta el modo buffer. Laforma más elegante de evitar estos problemas es definir señales de apoyo en la arquitectura. Al estardefinidas en la arquitectura, no tienen modo y pueden escribirse sin problemas en los port map. Lasverdaderas variables pueden ser obtenidas a partir de las de apoyo por simples asignaciones.

MÁS ATENCIÓN: MaxPlusII no permite el uso de constantes como puertos de componentes enel comando port map. Es necesario usar siempre señales. Esto no es en la práctica uninconveniente. Una señal llamada uno a la que se le asigna un '1' (uno<='1') fuera de un proceso ofunción es en la práctica una constante puesto que al ser un lenguaje concurrente no le puedoasignar un valor en ningún otro lugar del programa.

4. Poniendo orden: subprogramas, paquetes y bibliotecas.

Como otros lenguajes de programación, VDHL permite el uso de subprogramas, que contienenuna porción de código y a los cuales se les puede llamar. La instrucción component es, de algúnmodo, un subprograma. Veremos a continuación otras dos estructuras que permite el VHDL:funciones y procedimientos.

4.1. Funciones y procedimientos.

Son similares a las estructuras de otros lenguajes. Son subprogramas a los que se les pasan unosparámetros. Las diferencias entre funciones y procedimientos son:

-Una función siempre devuelve un valor, mientras que un procedimiento sólo puede devolvervalores a través de los parámetros que se le pasen.

-Los argumentos de una función son siempre de entrada (in), por lo que dentro de la función sólose pueden leer. No es necesario especificar el modo. En el procedimiento pueden ser de entrada, desalida o de entrada y salida, por lo que pueden sufrir modificaciones. Por defecto es in, pero out,buffer, e inout también son válidos.

-Una función no tiene efectos colaterales, pero un procedimiento sí, es decir, puede provocarcambios en objetos externos a él debido a que pueden cambiar las señales aunque no se hubieraespecificado en el argumento. Es decir, en los procedimientos se permite realizar asignaciones sobreseñales declaradas en la arquitectura y, por tanto, externas al procedimiento.

-Las funciones, como devuelven un valor, se usan en expresiones, mientras que losprocedimientos se llaman como una sentencia secuencial o recurrente.

-La función debe contener la palabra clave return seguida de una expresión puesto que siempredevuelve un valor, mientras que en el procedimiento no es necesario.



-Una función jamás puede tener la instrucción wait, mientras que un procedimiento sí.-En las funciones es necesario especificar qué tipo de objeto se devuelve. Como las funciones

siempre devuelven algo, esto implica que debe existir una instrucción return en el interior delcuerpo de la función, seguida de una expresión, que es precisamente lo que se devuelve. El uso dereturn en procedimientos es posible, pero no lleva una expresión puesto que los procedimientos nodevuelven nada. Simplemente, interrumpe la ejecución del procedimiento.

-Las funciones pueden definirse en la parte de declaraciones de una arquitectura, en cuyo caso ladefinición de la función sirve como declaración de la función. Este es el ejemplo que se muestramás abajo. Otra manera de definirlas es declararlas en un paquete "package", incluyendo ladefinición de la función en el cuerpo del paquete "package body". De esta forma, la definición dela función será visible a cualquier programa que utilice la orden use con el nombre del packagecorrespondiente. Lo mismo se aplica para los procedimientos.

Ejemplos:

El primer ejemplo es una célula sumadora de un bit construida con ayuda de una función,llamada majority. Esta función necesita tres parámetros, y da como resultado un bit.

entity full_add is port( a,b,carry_in: in bit; sum, carry_out: out bit);end entity;

architecture archfull_add of full_add is function majority (a,b,c: bit) return bit is begin return ((a and b) or (b and c) or (c and a)); end majority;

begin sum<=a xor b xor carry_in; carry_out<= majority(a,b,carry_in); end architecture;

El segundo ejemplo es una puerta or por procedimiento. Un procedimiento define una puerta or.Después, se llama a este procedimiento para realizar la puerta or en el programa principal.

entity or_con_procedimiento is port( a,b: in bit; z: out bit);end entity;

architecture arch of or_con_procedimiento is procedure dff (variable x1,x2:in bit; variable y: out bit) is begin y:=x1 or x2; end procedure;

begin

p: process(a,b) variable va,vb,vz: bit; begin va:=a;vb:=b; dff (va,vb,vz);



z<=vz; end process;

end architecture;

En MaxPlusII los procedimientos deben ser llamados con variables, por lo que también debentener como parámetros variables. Por ello, el cálculo de la puerta or se realiza a través de variables.En otros entornos informáticos esto no es necesariamente así. Los procedimientos en VHDL no sonalgo tan usado como en otros lenguajes como el Pascal. La forma "natural" de hacer subprogramasen VHDL es mediante el uso de componentes.

4.2. Bibliotecas, paquetes y unidades.

Para organizar ciertos diseños conviene definir ciertos elementos en una biblioteca, que luego seusará en el programa principal. En la biblioteca se pueden incluir los ficheros de algunos elementos,que incluyan las entidades y arquitecturas. Se incluyen también los paquetes ("packages"). Lospaquetes permiten introducir componentes (cuya definición de entidad y arquitectura puede estar enotro fichero), tipos, funciones y procedimientos. Tienen una parte declarativa y otra descriptiva. Porejemplo, las sentencias que están casi siempre a principio de todo programa son:


Esto indica el uso de la librería "ieee"; dentro de ella se usa el paquete "std_logic_1164"(sentencia use); y dentro del paquete se usan todos los elementos (".all"). Si se necesitase sólo uno,bastaría poner el nombre del elemento.

La forma concreta de organizar los directorios y ficheros depende de la herramienta informáticaconcreta que usemos.

Por ejemplo, en MaxPlus II, supongamos que queremos construir realmente el ejemplo descritoen el apartado 3.3 sobre la descripción estructural de programas. Allí se definieron dos componentesand3 y orn. Cada uno puede estar en su fichero .vhd, "and3.vhd" y "orn.vhd". Colocamos ambosficheros en un directorio, por ejemplo, en el directorio "c:\ejemplo". Compilamos cada uno de ellospor separado, como cualquier otro programa. Basta hacer una compilación funcional (con elcompilador activado, Processing/Functional SNF extractor), sin especificar una PLD concreta.Después habría que hacer el paquete correspondiente:


package puertas is

component or_de_n generic(n: integer:=2);port(a: in std_logic_vector(n-1 downto 0);y: out std_logic);end component;

component and_de_3 port( a,b,c: in std_logic; y: out std_logic);end component;end package;



El texto del package se guardaría en un fichero puerta.vhd, y se compilaría (el compiladorreconoce que es un paquete y actúa en consecuencia).

Si ahora queremos compilar un programa principal usando and3 y orn, una vez que está escritodeberíamos hacer lo siguiente antes de compilarlo:

a) En el editor de texto, en options- user libraries, se debe dar el "path" al directorio donde estánlos bloques y el package. En nuestro caso sería "c:\ejemplo"

b) Con el compilador activo, en interfaces-VHDL Netlist reader settings se le da el nombre a lalibrería y otra vez el "path" al directorio donde se encuentre. El nombre de la librería debe coincidircon el encabezamiento asociado a library en el programa principal. En el ejemplo del apartado 3.3.sería milibrería. Es independiente del nombre del directorio donde hayamos compilado el paquete.

c) Ya podemos compilar el programa principal, que deberá reconocer la nueva librería.

Las librerías existentes en MaxPlus II son las siguientes, según la ayuda on-line del propioprograma:

File Package Library Contentsmaxplus2.vhd maxplus2 altera MAX+PLUS II primitives, macrofunctions, and selected

megafunctions supported by VHDL.

megacore.vhd megacore altera Pre-tested megafunctions consisting of several differentdesign files.

std1164.vhdstd1164b.vhd

std_logic_1164 ieee Standard for describing interconnection data types for VHDLmodeling, and the STD_LOGIC andSTD_LOGIC_VECTOR types.

lpm_pack.vhd lpm_components lpm LPM megafunctions supported by VHDLarith.vhdarithb.vhd

std_logic_arith ieee SIGNED and UNSIGNED types, arithmetic and comparisonfunctions for use with SIGNED and UNSIGNED types, andthe conversion functions CONV_INTEGER,CONV_SIGNED, and CONV_UNSIGNED.

signed.vhdsignedb.vhd

std_logic_signed ieee Functions that allow MAX+PLUS II to useSTD_LOGIC_VECTOR types as if they are SIGNED types.

unsigned.vhdunsignedb.vhd

std_logic_unsigned ieee Functions that allow MAX+PLUS II to useSTD_LOGIC_VECTOR types as if they are UNSIGNEDtypes.

Algunas de estas librerías ofrecen funciones útiles. Destacamos por su especial interés:

a) operadores sobrecargados. Se llama así a la ampliación de una función u operador, paraadmitir otros tipos de entrada. Por ejemplo, el operador "+" sólo está definido para operar conenteros. Si queremos sumar una cadena de bits y un entero, podemos incluir la librería que incluyela definición de la función "+" ampliada. En MaxPlusII, el paquete std_logic_arith de la librería ieeeincluye la definición del tipo unsigned (cadena de bits entendida como un número positivo o cero),así como la función "+" suma de un unsigned y un entero. También se pueden sumarstd_logic_vector y enteros, si se incluyen tanto el paquete mencionado arriba como el paquetestd_logic_unsigned, que permite en ocasiones tratar al std_logic_vector como un unsigned.

Es interesante también la posibilidad de cambio de tipo: paso a entero, a unsigned, a signed o astd_logic. Para más información, leer la ayuda on line acerca de "conversion functions".



b) Módulos parametrizados, LPM ("library of parametrized modules). Se trata de componentes"ya hechos" que se pueden llamar mediante la orden port map. La ventaja que presentan es la granoptimización a la que dan lugar durante la compilación y síntesis en una PLD.

MAX+PLUS II offers a variety of megafunctions, including LPM functions and otherparameterized functions. Megafunctions are listed here by function. Functions indicated by anasterisk (*) are provided for backward compatibility only.

Gates

lpm_and lpm_invlpm_bustri lpm_muxlpm_clshift lpm_orlpm_constant lpm_xorlpm_decode muxbusmux

Arithmetic Components

divide* lpm_comparelpm_abs lpm_counterlpm_add_sub lpm_dividelpm_mult

Storage Components

altdpram* lpm_latchcsfifo lpm_shiftregdcfifo* lpm_ram_dpscfifo* lpm_ram_dqcsdpram lpm_ram_iolpm_ff lpm_romlpm_fifo lpm_dff*lpm_fifo_dc lpm_tff*

Other Functions

clklock pll ntsc

Altera also offers a variety of MegaCore/OpenCore functions. These functions are available fromAltera's world-wide web site at http://www.altera.com.

5. Ejemplos de VHDL.

Daremos a continuación unos ejemplos de VHDL que cubran aspectos no tratadosanteriormente, pero que se encuentran a menudo en la síntesis de circuitos.



5.1. Flip-flop D síncrono.


entity biestD is port(clk,d: in std_logic;q: out std_logic);end entity;

architecture archbiestD of biestD isbegin

p: process(clk,d) begin if clk'event and clk='1' then q<=d; end if; end process;end;

Es importante darse cuenta de la detección del flanco de reloj, característica de todos lossistemas síncronos. Dentro de un proceso, un if con clk'event (detecta cambios en clk) y clk='1'(después del cambio vale uno) detecta un flanco de subida del reloj. Un flanco de bajada sería ifclk'event and clk='0'.

Todo lo que venga después de la detección del flanco de reloj corresponde a salidas que pasan através de biestables.

5.2. F-F tipo D con puesta a cero y a uno asíncronas.


entity biestD is port(clk,d: in std_logic;set,reset: in std_logic;q: out std_logic);end entity;

architecture archbiestD of biestD isbegin

p: process(clk,d,set,reset)beginif reset='1' then q<='0'; elsif set='1' then q<='1'; elsif clk'event and clk='1' then q<=d;end if;end process;end;

Hay que hacer notar que las condiciones del reset y del set van antes que la detección de la señalde reloj. Por ello, son asíncronas. Puedes intentar hacer un biestable con preset y puesta a uno



síncronas. También puedes verificar qué es lo que ocurre si set='1' y reset='1' ¿El biestable se pone acero o a uno?

5.3. Contadores.

Contador ascendente-descendente con carga paralelo síncrona y reset asíncrono:

library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_arith.all;use ieee.std_logic_unsigned.all;

entity contador is port(clk,load,up,reset: in std_logic;d: in std_logic_vector(7 downto 0);q: buffer std_logic_vector(7 downto 0));end entity;

architecture archcontador of contador isbegin

p: process(clk,d,q,load,up,reset)beginif reset='1' then q<=x"00"; elsif clk'event and clk='1' then if load='1' then q<=d; elsif up='1' then q<=q+1;

else q<=q-1; end if;end if;end process;

end architecture;

Es interesante la forma de definir un contador. Al incluir el paquete std_logic_arith defino el tipounsigned y la operación suma "+" de unsigned con enteros; con el paquete std_logic_unsigned sepuede tratar en ciertas situaciones un std_logic_vector como un unsigned (y sumarlo a un entero porejemplo). En este caso se podría haber definido directamente los vectores de entrada y salida comounsigned y usar sólo el paquete std_logic_arith.

También es interesante la definición del modo de q, como buffer. Ello es debido a que en laecuación q<=q+1, q aparece a la derecha, y una señal definida como modo out no podría ser leída.Otra manera de evitar esto, sería la creación de una señal auxiliar en la arquitectura queutilizaríamos dentro del proceso. Una vez fuera del proceso, podemos hacer que la salida sea igual aesa señal. De este modo, la salida nunca aparece a la derecha en una asignación.

Recordamos también que si un vector es definido como (3 downto 0), el bit 0 es el menossignificativo.

Finalmente, hacemos notar también el uso de vectores en hexadecimal indicado por una xdelante del vector: x"00" es equivalente a 8 ceros binarios.

Un contador es también una máquina de estados, por lo que se puede definir como haremos en elapartado siguiente. No obstante, esta definición es mucho más pesada.



5.4. Máquinas de estado.

La máquina de estado tiene una parte donde se describe la tabla de evolución de estados, y otraparte donde se describe las salidas. Consideremos un ejemplo: dos sensores en la vía del trenindican cuando pasa el tren por la vía (la vía es bidireccional). Los sensores se encuentran a amboslados de un cruce con una carretera. Un semáforo debe ponerse en rojo cuando se detecte el pasodel tren.


entity semaforo is port(rs, a,b,clk: in std_logic;sem: out std_logic);

end;

architecture archsemaforo of semaforo isconstant size: integer:=2; signal estado: std_logic_vector(0 to size-1); constant e1: std_logic_vector(0 to size-1):="00"; constant e2: std_logic_vector(0 to size-1):="10"; constant e3: std_logic_vector(0 to size-1):="01"; constant e4: std_logic_vector(0 to size-1):="11"; begin p1: process (clk,rs,estado,a,b) begin if rs='1' then estado<=e1; elsif rising_edge(clk) then case estado is when e1 => if a='1' then estado<=e3; elsif b='1' then estado<=e2; else estado<=e1; end if; when e3 => if b='1' then estado<=e4; else estado<=e3; end if; when e2 => if a='1' then estado<=e4; else estado<=e2; end if; when e4 => if (a='0' and b='0') then estado<=e1; else estado<=e4; end if; when others => estado<=(others=>'-'); end case; end if; end process;-- decodificacion de las salidas; with estado select sem<='0' when e1, '1' when others;end archsemaforo;



Se ha definido el estado como un vector de std_logic. De esta forma, el programador eligetotalmente la codificación del estado. La inclusión de las constantes es simplemente por motivos declaridad, pero se podría prescindir de ellas y usar las cadenas de bits.

La función rising_edge() también detecta el flanco de subida mientras que falling_edge() detectael de bajada. Se aplica al tipo std_logic, pero no es aplicable al tipo bit.

Otra descripción alternativa podría ser definir un tipo con nombres de estado, más próximos allenguaje humano. Esto se haría en la arquitectura, antes del inicio (begin):

type tipoestado is (reposo, entra_por_a, entra_por_b, alejandose);signal estado: tipoestado;

De esta forma, he creado un nuevo tipo que puede ser uno de los estados (de igual modo que eltipo bit puede ser 1 o 0). Defino mi señal con ese nuevo tipo, y luego puedo usar esos nombres en elprograma, en lugar de cadenas de bits o nombres de constantes. La codificación de los estados laelegirá el compilador.

5.5. Salidas triestado.

Consideremos ahora el caso de una salida triestado.


entity triestado is port(enable,sel: in std_logic;linea: in std_logic_vector(1 downto 0);y : out std_logic);end entity;

architecture archtriestado of triestado isbegin

y<='Z' when enable='0' else linea(1) when sel='1' else linea(0) when sel='0';end architecture;

La salida en alta impedancia se indica con 'Z' (ojo, es Z, mayúscula).

Una salida de un biestable no se puede definir directamente como 'Z'. Para hacer que una salidade un registro esté en alta impedancia, se puede definir una señal en la arquitectura, que sea como lasalida del registro, o que esté en alta impedancia cuando se cumplan las condiciones adecuadas.

5.6. Puertos bidireccionales.



Consideremos el caso de un contador con las salidas en alta impedancia y con capacidad decarga por los mismos pines de salida del contador.

library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_arith.all;

entity ldcnt is port (clk, ld, oe: in std_logic;count_out: inout unsigned(7 downto 0));

end ldcnt;

architecture archldcnt of ldcnt issignal count: unsigned(7 downto 0);begincounter: process (clk,ld,oe,count_out,count)

beginif (ld='1' and oe='0') then

count <= count_out;elsif clk'event and clk='1' then

count <= count + 1;end if;

end process counter;count_out <= count when (oe = '1') else "ZZZZZZZZ";

end archldcnt;

Este contador se puede cargar por los mismos pines de salida (pines bidireccionales). Tales tiposde puertos son necesariamente de tipo inout. El sistema que controla las entradas ld y oe debe hacerque cuando se cargue un valor (ld='1'), a la vez no se habilite la salida (oe='0').

Bibliografía

K. Skahill, "VHDL for Programmable Logic", Ed. Addison-Wesley, 1996. Incluye en un CD-ROM elprograma Warp2.F. Pardo, J.A. Boluda. "VHDL: Lenguaje para síntesis y diseño de circuitos digitales". Ed. Rama, 1999.Incluye un CD-ROM con un simulador (Veribest) de VHDL (máximo 2000 líneas de código), y unaherramienta de Altera, MaxII-Plus, aunque la versión ya está desfasada.S. Olloz, E. Villar, Y. Torroja, L. Teres: "VHDL, lenguaje estándar de diseño electrónico", Ed. McGraw-Hill.www.altera.com Distribuye gratis un software (Max-Plus II) que admite entrada en VHDL y en AHDL,captura esquemática, simulación funcional y temporal. Cada cierto tiempo actualiza las versiones libres. Esuna herramienta mucho más completa que Warp2.Otras páginas Web:http://tech-www.informatik.uni-hamburg.de/vhdl/www.cypress.comwww.xilinx.comwww.actel.comwww.synopsis.com

lenguaje vhdl microelectronica

Documents