Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Bibliotecas VHDL

No description
by

TechnoTrancer DykTechnik

on 29 October 2012

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Bibliotecas VHDL

Bibliotecas VHDL Aldo Michael Cuahuizo Aca Una biblioteca en VHDL es el lugar donde se guarda la información relacionada con el diseño del programa.

Mediante bibliotecas podemos definir :
componentes,
funciones y
procedimientos

Las bibliotecas se estructuran en paquetes (packages) que permiten una fácil clasificación de los elementos que las componen.

La declaración de una librería sigue la siguiente sintaxis: library MiBiblioteca;
use MiBilioteca.Paquete1.all;
use MiBiblioteca.Paquete2.all; Al comienzo de cada diseño el compilador crea automáticamente una biblioteca llamada WORK para guardar el la información de nuestro diseño. Además de esta biblioteca existen otras de tipo general.
Un ejemplo de biblioteca general es la llamada Library IEEE.
Para utilizar una biblioteca general es necesario escribir su nombre al inicio del programa. LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL; Una de las bibliotecas más utilizadas es la denominada ieee, la cual contiene algunos tipos y funciones que completan a las que vienen por defecto en el propio lenguaje.

Algunos de los paquetes que incluye la biblioteca IEEE
IEEE.std_logic_1164
IEEE.std_logic_textio
IEEE.std_logic_arith
IEEE.numeric_bit
IEEE.numeric_std
IEEE.std_logic_signed
IEEE.std_logic_unsigned
IEEE.math_real
IEEE.math_complex Biblioteca IEEE Éste paquete define los siguientes tipos de datos y funciones.

•The std_ulogic type
•The std_logic type
•The std_ulogic_vector type
•The std_logic_vector type
•The to_bit function
•The to_stdulogic function
•The to_bitvector function
•The to_stdlogicvector function
•The rising_edge function
•The falling_edge function
•The is_x function std_logic_1164 Este tipo es usado para representar el valor de una señal digital en un cable. Para un uso general es recomendado usar el tipo std_logic.
Una señal o variable de este tipo puede tomar los siguientes valores :

•'U': uninitialized. This signal hasn't been set yet.
•'X': unknown. Impossible to determine this value/result.
•'0': logic 0
•'1': logic 1
•'Z': High Impedance
•'W': Weak signal, can't tell if it should be 0 or 1.
•'L': Weak signal that should probably go to 0
•'H': Weak signal that should probably go to 1
•'-': Don't care.

las operaciones lógicas definidas en éste tipo son: and, nand, or, nor, xor, xnor, not. The std_ulogic type Es un subtipo de std_ulogic corresponde a la version "resuelta" de ésta. The std_logic type std_logic_1164 NOT: The std_logic type std_logic_1164 AND: std_logic_1164 OR: function function_name (parameters) return type is
declarations
begin
sequential statements
end function function_name;


function function_name (parameters) return type; The std_ulogic type The std_logic_vector type signal s1, s2, s3 : std_logic_vector(3 downto 0);
...
s1(0) <= '0';
s1(1) <= '1';
s1(2) <= '1';
s1(3) <= '0';
s2 <= "1100"; -- sets s(3),s(2) to '1', s(1),s(0) to '0': same order as range in declaration
s3 <= s2 -- copies all of s2 into s3
s3 <= s1 and s2; -- "0100" The to_bit function function to_bit ( s : std_ulogic ) return bit; Convierte un valor del tipo std_ulogic o del tipo std_logic en un valor definido en VHDL del tipo bit. The to_stdulogic function function to_stdulogic ( b : bit ) return std_ulogic; Convierte un valor del tipo bit en uno de tipo std_ulogic. The to_bitvector function function to_bitvector ( s : std_ulogic_vector ) return bit_vector; Convierte un vector std_ulogic_vector o std_logic_vector en un vector de bits. The to_stdlogicvector function function to_stdlogicvector ( b : bit_vector ) return std_logic_vector; Convierte un vector de bits en un vector std_logic_vector. The rising_edge function function rising_edge ( signal s : std_ulogic ) return boolean; Detecta el cambio de una señal std_ulogic o std_logic. Devuelve true cuando la señal cambia de un valor bajo ('0' or 'L') a uno alto ('1' or 'H'). The falling_edge function function falling_edge ( signal s : std_ulogic ) return boolean; Detecta el cambio de una señal std_ulogic o std_logic. Devuelve true cuando la señal cambia de un valor alto ('1' or 'H') a uno bajo ('0' or 'L'). The is_x function function is_x ( s : std_ulogic ) return boolean;
function is_x ( s : std_ulogic_vector ) return boolean;
function is_x ( s : std_logic_vector ) return boolean; Recibe un argumento std_ulogic o std_logic, esta función devuelve true si el valor es uno de los valores indefinidos ('U', 'X', 'Z', 'W', '-'). Devuelve false en caso contrario.
Si el argumento es un vector, la función retorna verdadero si cualquiera de los elementos cumple la condición. La bilbioteca permite tanto escribir como leer datos formateados de ficheros.

En ella existe el tipo básico FILE:



la línea se declara como una variable del tipo line:

Para controlar el fin de fichero se utiliza la función ENDFILE:

Para copiar una línea del fichero de entrada sobre la variable tipo line se utiliza lafunción READLINE y para escribir sobre el fichero de salida una línea se utiliza lafunción WRITELINE. Su sintaxis es:


para extraer un argumento de la línea leída se utiliza la función READ:


Finalmente para escribir argumentos se utiliza WRITE: std_logic_textio Define algunos tipos y operaciones basicas aritmeticas para representar enteros de una forma estandar. Es una extensión de Synopsys .

•The unsigned type
•The signed type
•The arithmetic functions: +, -, *
•The comparison functions: <, <=, >, >=, =, /=
•The shift functions: shl, shr
•The conv_integer function
•The conv_unsigned function
•The conv_signed function
•The conv_std_logic_vector function std_logic_arith FILE infile : TEXT IS IN “fichero.in”;
FILE outfile : TEXT IS OUT “fichero.out”; VARIABLE lineaent, lineasal: LINE; WHILE NOT (ENDFILE( infile ))LOOP……..END LOOP; READLINE (infile, lineaent);
WRITELINE (outfile,lineasal); READ (lineaent, argumento1);
READ (lineaent, argumento2); WRITE (lineasal, argumento1);
WRITE (lineasal, argumento2); The unsigned type Tiene la misma definicion que std_logic_vector y signed type, asi que las operaciones son las mismas
La diferencia se da al intentar usarlo como número, ya que será tratado como un entero codificado en binario, con el bit más significativo en la primera posición del arreglo. The signed type Tiene la misma definicion que std_logic_vector y signed type, asi que las operaciones son las mismas
La diferencia se da al intentar usarlo como número, ya que será tratado como un entero con signo codificado en binario complementado a 2, con el bit más significativo en la primera posición del arreglo. The arithmetic functions Las operaciones básicas aritmeticas, suma(+), resta(-) y multiplicación(*) están definidas en los tipos unsigned y signed.

Los operadores + y - también son usados para indicar valores positivos o negativos

Cada uno de los operadores puede tomar valores del tipo unsigned, signed and integer como argumentos, y pueden regresar valores unsigned, signed or std_logic_vector.
Sin embargo NO se permiten operaciones aritmeticas con std_logic_vector, porque es imposible determinar si un vector particular esta representando valores con signo o sin signo. Para hacer esto se recomienda usar los paquetes std_logic_unsigned o std_logic_signed. The comparison functions Las operaciones básicas de comparación: menor que (<), menor o igual que (<=),
mayor que (>), mayor o igual que (>=), igual a (=) y diferente de (/=) estan definidas para los tipos unsigned and signed.
Cada uno de los operadores puede tomar valores del tipo unsigned, signed and integer como argumentos, y todas ellas regresan valores booleanos.

Tampoco puede hacer operaciones en std_logic_vector por las razones ya conocidas anteriormente. The shift functions Las operaciones de dezplazamiento de bit: shift left (shl) y shift right (shr) estan definidas para los tipos unsigned y signed. The conv_integer function Estas funciones convierten el argumento a un entero. Si el argumento contiene un elemento indefinido, se muestra una advertencia en tiempo de ejecución y es regresado un cero.
La función provista por std_logic_arith NO puede convertir std_logic_vector.
Sin embargo las funciones que permiten realizarlo se encuentran en los paquetes std_logic_unsigned y std_logic_signed. The conv_unsigned function Éstas funciones convierten el argumento a un valor del tipo unsigned.
Sin poder convertir a un std_logic_vector The conv_signed function Éstas funciones convierten el argumento a un valor con signo complementado a 2's.
*Excepto std_logic_vector The conv_std_logic_vector function Éstas funciones convierten el argumento a un valor std_logic_vector.
Si el argumento es unsigned o positive, será tratado como un valor unsigned; si es negativo será convertido a complemento a 2's. signal u1, u2 : unsigned (3 downto 0);
signal s1 : signed (3 downto 0);
signal s2 : signed (4 downto 0);
signal v1 : std_logic_vector (3 downto 0);
signal v2 : std_logic_vector (4 downto 0);
signal i1, i2 : integer;
...
u1 <= "1001"; -- = 9
s1 <= "1001"; -- = -7
i1 <= 16;
s2 <= u1 + s1; -- = 2
v2 <= u1 + s1; -- = "0010"
u2 <= i1 - u1; -- = 7
s1 <= -s1; -- = 7 signal u1, u2 : unsigned (3 downto 0);
signal s1 : signed (3 downto 0);
signal o1,o2 : std_logic;
...
u1 <= "1001"; -- = 9
u2 <= "0111"; -- = 7
s1 <= "1001"; -- = -7
if u1 > u2 then
o1 <= '1'; -- o1 set to '1'
else
o1 <= '0';
end if;
if s1 > u2 then
o2 <= '1';
else
o2 <= '0'; -- o2 set to '0'
end if; 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; 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; signal b : std_logic;
signal u1 : unsigned (3 downto 0);
signal s1 : signed (3 downto 0);
signal i1, i2, i3 : integer;
...
u1 <= "1001";
s1 <= "1001";
b <= 'X';
i1 <= conv_integer(u1); -- 9
i2 <= conv_integer(s1); -- -7
i3 <= conv_integer(b); -- warning produced in simulator 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; signal u1, u2 : unsigned (3 downto 0);
signal s1 : signed (3 downto 0);
signal i1, i2 : integer;
...
s1 <= "0101";
i1 <= 13;
u1 <= conv_unsigned(s1, 4); -- = "0101" = 5
u2 <= conv_unsigned(i1, 4); -- = "1101" = 13 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; signal u1 : unsigned (3 downto 0);
signal s1, s2, s3 : signed (3 downto 0);
signal i1, i2 : integer;
...
u1 <= "0101";
i1 <= 6;
i2 <= -2;
s1 <= conv_signed(u1, 4); -- = "0101" = +5
s2 <= conv_signed(i1, 4); -- = "0110" = +6
s3 <= conv_signed(i2, 4); -- = "1110" = -2 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; signal u1 : unsigned (3 downto 0);
signal s1 : signed (3 downto 0);
signal v1, v2, v3, v4 : std_logic_vector (3 downto 0);
signal i1, i2 : integer;
...
u1 <= "1101";
s1 <= "1101";
i1 <= 13;
i2 <= -3;

v1 <= conv_std_logic_vector(u1, 4); -- = "1101"
v2 <= conv_std_logic_vector(s1, 4); -- = "1101"
v3 <= conv_std_logic_vector(i1, 4); -- = "1101"
v4 <= conv_std_logic_vector(i2, 4); -- = "1101" Este paquete contiene funciones de operaciones aritmeticas para vectores con y sin signo



sign changing operators
abs, -
arithmetic operators
+,-,*,/,rem,mod.
>,<,<=,>=,=,/=
SHIFT_LEFT,SHIFT_RIGHT, ROTATE_LEFT, ROTATE_RIGHT, sll, srl, rol, ror
resize function
RESIZE(v,n)

TO_INTEGER, TO_UNSIGNED, TO_SIGNED

not, and, or, nand, nor, xor, xnor
match function
STD_MATCH

TO_01 numeric_bit type UNSIGNED is array (NATURAL range <> ) of BIT;
type SIGNED is array (NATURAL range <> ) of BIT; Es casi identico a NUMERIC_BIT excepto que los tipos UNSIGNED y SIGNED son declarados en terminos de STD_LOGIC del paquete Std_Logic_1164



sign changing operators
abs, -
arithmetic operators
+,-,*,/,rem,mod.
>,<,<=,>=,=,/=
SHIFT_LEFT,SHIFT_RIGHT, ROTATE_LEFT, ROTATE_RIGHT, sll, srl, rol, ror
resize function
RESIZE(v,n)

TO_INTEGER, TO_UNSIGNED, TO_SIGNED

not, and, or, nand, nor, xor, xnor
match function
STD_MATCH

TO_01 numeric_std type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;
type SIGNED is array (NATURAL range <>) of STD_LOGIC; numeric_bit function TO_INTEGER (ARG : UNSIGNED) return NATURAL;
function TO_INTEGER (ARG : SIGNED) return INTEGER;
function TO_UNSIGNED (ARG, SIZE : NATURAL) return UNSIGNED;
function TO_SIGNED (ARG : INTEGER; SIZE : NATURAL) return SIGNED;
function RESIZE (ARG : SIGNED; NEW_SIZE : NATURAL) return SIGNED;
function RESIZE (ARG : UNSIGNED; NEW_SIZE : NATURAL) return UNSIGNED;
-- set XMAP to convert unknown values, default is 'X'->'0'
function TO_01(S : UNSIGNED; XMAP : STD_LOGIC := '0') return UNSIGNED;
function TO_01(S : SIGNED; XMAP : STD_LOGIC := '0') return SIGNED;
function STD_MATCH (L, R: T) return BOOLEAN; Esta biblioteca extiende a la biblioteca std_logic_arith para manejar valores como enteros sin signo std_logic_vector (unsigned integers).
Es una extensión de Synopsys.
Esta biblioteca defina las mismas operaciones aritméticas (+, -, *), comparación (<, <=, >, >=, =, /=) y operaciones de desplazamiento (shl, shr) tal como la biblioteca std_logic_arith.
La diferencia es que toman los valores como argumentos y los tratan como enteros sin signo.
La función conv_integer también está definida en std_logic_vector y trata el valor como un entero sin signo. std_logic_unsigned La biblioteca extiende a la biblioteca std_logic_arith para manejar valores de enteros con signo std_logic_vector.
Es una extensión de Synopsys.
Esta biblioteca defina las mismas operaciones aritméticas (+, -, *), comparación (<, <=, >, >=, =, /=) y operaciones de desplazamiento (shl, shr) tal como la biblioteca std_logic_arith.
La diferencia es que toman los valores como argumentos y los tratan como enteros con signo complementados a 2. std_logic_signed math_real constant MATH_E : REAL := 2.71828_18284_59045_23536; -- Value of e
constant MATH_1_OVER_E : REAL := 0.36787_94411_71442_32160; -- Value of 1/e
constant MATH_PI : REAL := 3.14159_26535_89793_23846; -- Value of pi
constant MATH_2_PI : REAL := 6.28318_53071_79586_47693; -- Value of 2*pi
constant MATH_1_OVER_PI : REAL := 0.31830_98861_83790_67154; -- Value of 1/pi
constant MATH_PI_OVER_2 : REAL := 1.57079_63267_94896_61923; -- Value of pi/2
constant MATH_PI_OVER_3 : REAL := 1.04719_75511_96597_74615; -- Value of pi/3
constant MATH_PI_OVER_4 : REAL := 0.78539_81633_97448_30962;-- Value of pi/4
constant MATH_3_PI_OVER_2 : REAL := 4.71238_89803_84689_85769; -- Value 3*pi/2
constant MATH_LOG_OF_2 : REAL := 0.69314_71805_59945_30942; -- Natural log of 2
constant MATH_LOG_OF_10 : REAL := 2.30258_50929_94045_68402; -- Natural log of 10
constant MATH_LOG2_OF_E : REAL := 1.44269_50408_88963_4074; -- Log base 2 of e
constant MATH_LOG10_OF_E: REAL := 0.43429_44819_03251_82765; -- Log base 10 of e
constant MATH_SQRT_2: REAL := 1.41421_35623_73095_04880; -- square root of 2
constant MATH_1_OVER_SQRT_2: REAL := 0.70710_67811_86547_52440; -- square root of 1/2
constant MATH_SQRT_PI: REAL := 1.77245_38509_05516_02730; -- square root of pi
constant MATH_DEG_TO_RAD: REAL := 0.01745_32925_19943_29577; -- Conversion factor from degree to radian
constant MATH_RAD_TO_DEG: REAL := 57.29577_95130_82320_87680; -- Conversion factor from radian to degree function conv_integer(arg: std_logic_vector) return integer; math_real function SIGN (X: in REAL ) return REAL;
function CEIL (X : in REAL ) return REAL;
function FLOOR (X : in REAL ) return REAL;
function ROUND (X : in REAL ) return REAL;
function TRUNC (X : in REAL ) return REAL;
function REALMAX (X, Y : in REAL ) return REAL;
function REALMIN (X, Y : in REAL ) return REAL;
function SQRT (X : in REAL ) return REAL;
function CBRT (X : in REAL ) return REAL;
function "**" (X : in INTEGER; Y : in REAL) return REAL;
function "**" (X : in REAL; Y : in REAL) return REAL;
function EXP (X : in REAL ) return REAL;
function LOG (X : in REAL ) return REAL;
function LOG2 (X : in REAL ) return REAL;
function LOG10 (X : in REAL ) return REAL;
function LOG (X: in REAL; BASE: in REAL) return REAL;
function COS ( X : in REAL ) return REAL;
function TAN (X : in REAL ) return REAL;
function ARCSIN (X : in REAL ) return REAL;
function ARCCOS (X : in REAL ) return REAL;
function ARCTAN (Y : in REAL) return REAL;
function ARCTAN (Y : in REAL; X : in REAL) return REAL;
function SINH (X : in REAL) return REAL;
function COSH (X : in REAL) return REAL;
function TANH (X : in REAL) return REAL;
function ARCSINH (X : in REAL) return REAL;
function ARCCOSH (X : in REAL) return REAL;
function ARCTANH (X : in REAL) return REAL; math_complex type COMPLEX is record RE, IM: real; end record;
type COMPLEX_VECTOR is array (integer range <>) of COMPLEX;
type COMPLEX_POLAR is record MAG: real; ARG: real; end record;

constant CBASE_1: complex := COMPLEX'(1.0, 0.0);
constant CBASE_j: complex := COMPLEX'(0.0, 1.0);
constant CZERO: complex := COMPLEX'(0.0, 0.0);

function CABS(Z: in complex ) return real;
-- returns absolute value (magnitude) of Z

function CARG(Z: in complex ) return real;
-- returns argument (angle) in radians of a complex number

function CMPLX(X: in real; Y: in real:= 0.0 ) return complex;
-- returns complex number X + iY

function "-" (Z: in complex ) return complex;
-- unary minus

function "-" (Z: in complex_polar ) return complex_polar;
-- unary minus

function CONJ (Z: in complex) return complex;
-- returns complex conjugate

function CONJ (Z: in complex_polar) return complex_polar;
-- returns complex conjugate

function CSQRT(Z: in complex ) return complex_vector;
-- returns square root of Z; 2 values

function CEXP(Z: in complex ) return complex;
-- returns e**Z

function COMPLEX_TO_POLAR(Z: in complex ) return complex_polar;
-- converts complex to complex_polar

function POLAR_TO_COMPLEX(Z: in complex_polar ) return complex;
-- converts complex_polar to complex
Full transcript