Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                

VHDL

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 31

Implementación de RTL usando

VHDL
Elementos Esenciales
Introducción a VHDL
VHDL es uno de los lenguajes para la descripción de circuitos digitales de mas
amplio uso en el campo de la Ingeniería de los Sistemas Digitales. Sus siglas VHDL
indica que es un Lenguaje para la Descripción del Hardware orientado hacia el
diseño de circuitos integrados de muy alta velocidad.

VHDL cuenta con un buen respaldo a nivel comercial y por lo tanto existe una gran
cantidad de herramientas que respaldan el uso de el mismo. Compañías tales como
Xilinx y Altera entre otras proporcionan paquetes de software y tarjetas digitales
con dispositivos de lógica programable para el desarrollo de soluciones usando
este lenguaje de descripción.

Este curso es sobre el diseño Microprocesadores por lo tanto VHDL servirá de gran
apoyo para la realización de este fin.

A continuación se presenta una breve descripción de algunos de los elementos mas


utilizados del VHDL enfocados siempre hacia la realización de un sistema digital
que como los microprocesadores pueda ser dividido en dos secciones principales,
la Sección de Datos y la Sección de Control.
Secciones de un módulo descrito
usando VHDL.

• Entity.
• Architecture.
• Process.
• Component.
• Signal.
Entity
Define el nombre del sistema digital, sus
entradas y salidas. Las entradas pueden ser
escalares o vectores, otros tipos de entradas
incluyen variables enteras o reales.
Declaración de una Entidad

Identificadores: el nombre Agrupar: las señales que tienen igual modo e igual
utilizado debe seguir un conjunto tipo e igual dimensión se pueden declarar agrupadas
de reglas, de otra forma el siguiendo el siguiente formato
compilador VHDL señala un error port ( grupo_1; grupo2_; … grupo_n);
grupo_i | señal_1, señal_2, … señal_n: modo tipo
IDENTIFICADORES.
Declaración de una entidad que usa vectores
Declaración de una entidad con una variable genérica

entity ADDR is
generic (n : integer);
Port ( A, B : in BIT_VECTOR (0 to n-1);
Cin : in BIT;
Suma : out BIT_VECTOR (0 to n)); **Cout está en Suma(0).
end ADDR;
LIBRERIAS en VHDL
Las librería incluyen otros tipos de señales y variables que pueden ser de mayor
utilidad que las convencionales. La mas usada es la IEEE y la work

IEEE
Que contiene el paquete std_logic_1164.

work
Donde se hallan los paquetes numeric_std,
std_arith y gatespkg. En esta librería se
almacenan los diseños realizados.
Declaración de Librería.
Entidades que usan vectores del tipo standard logic
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity PROM is
Port ( A : in STD_LOGIC_VECTOR(0 to 1);
B : in STD_LOGIC_VECTOR (0 to 1);
C : out STD_LOGIC_VECTOR (0 to 1));
end PROM;

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity MULTIVECTOR is
Port ( E0, E1, E2, E3 : in STD_LOGIC _VECTOR (3 downto 0);
S0, S1 : in STD_LOGIC;
F : out STD_LOGIC _VECTOR (3 downto 0));
end MULTIVECTOR;
ARCHITECTURE

La entidad describe el módulo desde sus


terminales.
La arquitectura define su realización. La
sintaxis generalizada de la arquitectura es:
ARCHITECTURE
architecture arch_name of entity_name is
-- nuevos tipos
-- señales
-- componentes
begin
-- operaciones lógicas aritméticas concurrentes;
-- asignaciones a señales;
process
begin
-- código de descripción
end process;
end arch_name;
Operaciones Lógicas:
and or not nand nor xor xnor
(se pueden aplicar a bits y a vectores).
Operaciones Aritméticas:
+ - (suma y resta )
& (Concatenación)
* ** / mod rem (Multiplicacion, potencias,
división, módulo y residuo)

Operaciones Relacionales:
= | /= | < | <= | > | >=
(igual, diferente, menor que, menor o igual, mayor, mayor o igual)

Operaciones de Traslación:
sll | srl | sla | sra | rol | ror
(a la izquierda, lógica a la derecha, aritmética a la derecha, rotación
izquierda, rotación derecha)
Ejemplos de uso de operadores
Ejemplo:
ENTITY example1 IS
PORT ( x1, x2, x3 : IN BIT ;
f : OUT BIT ) ;
END example1 ;

ARCHITECTURE LogicFunc OF example1 IS


BEGIN
f <= (x1 AND x2) OR (NOT x2 AND x3) ;
END LogicFunc ;
==========================================================
entity mux2 is
port (D0, D1, S0: in std_logic;
O : out std_logic);
end mux2;

architecture behavioral2 of mux2 is


begin
multiplexor: process( D0,D1,S0)
if(S0 = ‘1’) then O <= D1;
else O <= D0;
end if;
end process;
end behavioral2;
PROCESS
El proceso la sección que contiene las operaciones que se
ejecutan secuencialmente. El proceso posee el siguiente
formato:

<etiqueta>: process (lista de entradas)


begin
-- operaciones o estructuras secuenciales
end process <etiqueta>
-- la etiqueta es opcional
PROCESS
La mayoría de las estructuras de control son secuenciales por lo que solamente
pueden incluirse como parte de procesos.

IF – ELSIF – ELSE – END IF :


IF(condición_lógica_1) then
-- operaciones que se ejecutan si la
-- condición 1 se cumple
ELSIF(condición_lógica_2) then
-- operaciones que se ejecutan si la
-- condición 1 no se
-- cumple, pero si la condición 2.
ELSE
-- operaciones que se ejecutan si ni la
-- condición 1 ni la 2 se cumplen.
END IF; -- señala el cierre de la estructura.
PROCESS
FOR – GENERATE;
<etiqueta>: FOR <índice> IN (valor inicial) TO
(valor final) GENERATE
<asignación1 que depende de índice> ;
<asignación2 que depende de índice> ;

END GENERATE ;

CASE – WHEN
case expresión is
when alternativa_l => ... --seq. statements

when alternativa_n => ... --seq. statements
when others => ... --seq. statements
end case;
Ejemplo if – end if

Arquitectura
funcional de la
entidad comp.
Ejemplo CASE– WHEN

ENTITY mux2to1 IS
PORT ( w0, w1, s : IN STD_LOGIC ;
f : OUT STD_LOGIC ) ;
END mux2to1 ;

ARCHITECTURE Behavior OF mux2to1 IS


BEGIN
PROCESS ( w0, w1, s )
BEGIN
CASE s IS
WHEN '0' => f <= w0 ;
WHEN OTHERS => f <= w1 ;
END CASE ;
END PROCESS ;
END Behavior ;
Ejemplo FOR – GENERATE

component log
port( x: in bit; y: out bit);
end component log

signal a, b: bit_vector(0 to 7)

gen: for i in 0 to 7 generate
u: log port map(a(i),b(i));
end generate gen;
Arquitectura con declaraciones concurrentes:

Declaraciones
concurrentes
Arquitectura con declaraciones concurrentes:

Declaraciones lógicas
concurrentes
Concurrente o Secuencial

Operaciones concurrentes:
El circuito generado no depende del orden en el que se disponen
las operaciones ya que todas las conexiones ilustradas se concretan
simultáneamente. Todas las operaciones dispuestas en el cuerpo de una
arquitectura y fuera del cuerpo de un proceso son concurrentes.

Operaciones secuenciales:
El circuito se genera de acuerdo al orden dispuesto en la
secuencia. Todas las operaciones dispuestas en el cuerpo de un proceso son
secuenciales.
Descripción de un biestable con entrada de control alto-activa
Para la declaración de flip-flops se usan estructuras secuenciales en un proceso:
Ejemplo: Describa un flip-flop tipo D con entrada de control alto activa “C”.
Solución:

entity Biestable_D is
port (D, C: in bit;
Q: out bit);
end Biestable_D;
architecture ARCH of Biestable_D is
begin
process (C)
begin
if (C = '1') then Q <= D ;
end if ;
end process
end ARCH ;
Flip-flops en VHDL
Describir un flip-flop tipo D con entrada de reloj “clk” activada por flanco
negativo.

FFD: process (clk, D)


begin
if (clk’event and clk = ‘0’) then
Q <= D;
end if;
end process FFD;

Se usa el atributo ‘event para señalar un evento en la


entrada de reloj. También es posible usar
falling_edge(clk) que es lo mismo que clk’evento and
clk = ‘0’
Descripción de un flip-flop D con entrada de reloj activada por
el flanco de subida y entrada cr asincrónica.
entity Biestable_rD is
port( D, clk, cr: in bit;
Q: out bit);
end Biestable_rD;

architecture ARCH of Biestable_rD is


begin
process (clk, cr, D)
begin
if ( cr = '0') then
Q <= '0' ;
elsif clk = '1' and clk'event then
Q <= D ;
end if ;
end process ;
end ARCH ;
Flip-flop tipo D con entrada de clear y preset.
Ejemplo:
Presente la descripción de un flip-flop tipo D con entrada de clear ‘nCR’ y preset ‘nPR’,
la entrada de reloj es activa en el flanco de atraso.

process (CLK,nPR,nCR)
begin
if nCR = '0' then
Q <= '0' ;
elsif nPR = '0' then
Q <= '1' ;
elsif (CLK'event and CLK = ‘0') then
Q <= D ;
end if ;
end process;

Se realiza un flip-flop tipo D cuya entrada clear posee prioridad superior a CLK y a D
Registros en VHDL
Las declaraciones en VHDL de los registros es similar a los flip-flops con la
diferencia de que ahora las entradas son declaradas como vectores,
ejemplo:
Signals
Muchas veces se utilizan recursos que solo se reflejan en la arquitectura y no en
la entidad ya que no son ni entradas ni salida. Este tipo de recursos se declaran
como “signal”, cuyo formato es :

architecture algun_circuito of alguna_entidad is


signal señal_interna: std_logic;
signal vector_interno: std_logic_vector( 0 to n);
...
begin
...

La declaración de la señal va después del inicio de la arquitectura pero antes del


begin del cuerpo de la arquitectura.
Lugar donde se agrupan las declaraciones de componentes y de otros tipos
nuevos de señales.
Componentes
Este recurso nos permite crear módulos que posteriormente podremos utilizar para
agilizar nuestro diseño. Los componentes están orientados para ser almacenados
en paquetes pero se pueden especificar con archivos dentro de un proyecto.
Para poder utilizar un diseño como un componente hay que declararlo como tal ya
sea en una librería propia o dentro del módulo donde será utilizado.

Definición de la entidad en el Declaración del componente en el


diseño del componente diseño donde será utilizado.

También podría gustarte