Vhdl introduccion



Descargar 95,53 Kb.
Página6/6
Fecha de conversión22.07.2017
Tamaño95,53 Kb.
1   2   3   4   5   6

TIPO STD_LOGIC

  • Hay otro tipo definido, llamado “std_logic”.
  • el cual es una versión tipo resolved de std_ulogic y puede tener mas de un driver.
  • El tipo std_logic tiene los mismos nueve estados de std_ulogic.

VECTORES TIPO STD_LOGIC Y STD_ULOGIC

  • El paquete también contiene la definición de los arreglos de std_logic y std_ulogic, conocidos como std_logic_vector y std_ulogic_vector. estos tipos tienden a ser usados para describir estructuras de bus en la forma como el tipo bit_vector.
  • Los tipos std_logic y std_logic_vector, son los recomendados para usar en los diseños.
  • La razón para esto es que hay otros estandares para usar VHDL que están basados en estos tipos en lugar de std_ulogic y std_ulogic_vector.

Asignar std_logic a std_ulogic.

  • Como se muestra en el diagrama es posible asignar objetos de tipo std_logic a objetos del tipo std_ulogic, y viceversa.
  • signal A,B,Z: std_ulogic;
  • signal RES_Z: std_logic
  • Z<=A;
  • RES_Z<=A;
  • A<=RES_Z;

std_logic para drivers múltiples

  • Si hay múltiples drivers en una señal se debe usar el tipo std_logic, ya que no es valido tener mas de un driver en un tipo de dato unresolved.
  • Z o RES_Z ?
  • signal A,B,Z: std_ulogic;
  • signal RES_Z: std_logic;
  • Z<= A;
  • Z<= B;
  • RES_Z<= A;
  • RES_Z<= B;

Cláusulas library y use

  • El paquete de definiciones está contenido en una biblioteca llamada IEEE. Es necesario hacer referencia tanto a la biblioteca como al paquete, como es mostrada en el diagrama. Se deben usar estas líneas de código antes de describir las entidades que usan en el Standard Logic.
  • library IEEE; --hace visible la biblioteca
  • use IEEE.Std.Logic_1164.all; --hace todo el contenido del paquete visible
  • entity MVLS is
  • port (A,B: in std_ulogic;
  • Z: out std_ulogic);
  • end MVLS;

OPERADORES LOGICOS

OPERADORES RELACIONALES

  • Los operadores deben ser del mismo tipo, pero el número de bits comparados puede ser diferentes.

OPERADORES ARITMETICOS

    • Operan sobre objetos de tipo INTEGER.
    • Pueden igualmente operar sobre STD_LOGIC_VECTOR utilizando los paquetes STD_LOGIC_UNSIGNED y STD_LOGIC_ARITH.

OPERADORES DE DESPLAZAMIENTO

      • rol ( rotate left )
      • ror ( rotate right )
      • sll ( shift left logical )
      • srl ( shift rigth logical )
      • sla ( shift left arithmetic )
      • sra ( shift right arithmetic )
  • Operan sobre objetos de tipo:
    • bit_vector
    • std_logic_vector, std_ulogic_vector

INSTRUCCIONES SECUENCIALES Y CONCURRENTES

Sentencias secuenciales y concurrentes

  • Sentencias concurrentes. Se ejecutan al mismo tiempo.
  • En paralelo.
  • Sentencias secuenciales. Se ejecutan una a la vez.
  • En secuencia.

Instrucciones concurrentes

  • Las operaciones se efectúan al mismo tiempo (en paralelo) :
  • El orden de escritura de las instrucciones no afecta el resultado de la síntesis o simulación.
  • El estilo de escritura es comparable a los lenguajes de programación de los PALs (ecuaciones lógicas).

Ejemplo

  • Entity CONCURRENT is
  • port(A, B, C : in bit;
  • S, T : out bit); end CONCURRENT;
  • Architecture ARCHI of CONCURRENT is
  • begin
  • S <= (A and B) and not(C);
  • T <= B xor C;
  • end ARCHI;

Ejecución en paralelo orden independiente

  • El comportamiento de sentencias concurrentes es independiente del orden en el cual sean escritas.
  • X <= A + B;
  • Z <= C + X;
  • Z <= C + X;
  • X <= A + B;

Asignación concurrente

  • Los diseños esquemáticos son usados para representar hardware, por lo que son concurrentes por naturaleza.
  • X <= A + B;
  • Z <= C + X;
  • Z <= C + X;
  • X <= A + B;
  • +
  • +
  • A
  • B
  • C
  • Z

Asignación Concurrente

  • Consideremos la sentencia x <= x + y.
  • X <= x + y;
  • Registro X
  • Registro X
  • +

No para Hardware

  • Siendo una sentencia concurrente, esta misma línea de código está describiendo un sumador, sin registros de almacenamiento implícitos.
  • X <= x + y;
  • En Hardware;
  • +
  • x y
  • x

Instrucciones secuenciales

  • Las operaciones se efectúan en secuencia.
  • El orden afecta los resultados de simulación y sintésis.
  • Estilo de escritura parecido a los lenguajes de informática de alto nivel.
  • Las instrucciones secuenciales se usan en partes específicas del código: PROCESO o subprogramas.

Ejemplo

  • Architecture ARCHI of SECUENCIA is
  • begin
  • process begin
  • wait until CK’event and CK = ‘1’;
  • if ENA = ‘1’ then COUNT <= COUNT+1;
  • end if;
  • end process;
  • end ARCHI;
  • Utilización del Clock_Enable
  • Dedicado de los Flip Flops Xilinx

Instrucciones concurrentes

  • Asignación de señales por condición: WHEN…ELSE
  • Sintaxis:
  • Signal_x <= valor_x when signal_y = valor_y
  • else valor_z;
  • Notar que el valor_z es indicado directamente después de “else”. (El símbolo de asignación “<=” es implícito)

Ejemplo

  • entity CONCURRENT is
  • port (A, B, C : in bit; S, T : out bit);
  • end CONCURRENT;
  • architecture ARCHI of CONCURRENT is
  • begin
  • S <= A when C = ‘1’ else B;
  • T <= B xor C;
  • end ARCHI;

Ejemplo

  • entity CONCURRENT is
  • port (A, B, C : in bit; S, T : out bit);
  • end CONCURRENT;
  • architecture ARCHI of CONCURRENT is
  • Begin
  • if (c = ‘1’) then S <= A
  • else S <= B;
  • T <= B xor C;
  • end ARCHI;

Ejemplo

  • Entity CONCURRENT is
  • port (A, B, C : in bit; S, T : out bit);
  • end CONCURRENT;
  • architecture ARCHI of CONCURRENT is
  • begin
  • S <= A when C = ‘1’ else B;
  • T <= not B;
  • end ARCHI;

Las dos instrucciones (o asignaciones) son concurrentes. El orden de escritura no afecta los resultados.

  • Las dos instrucciones (o asignaciones) son concurrentes. El orden de escritura no afecta los resultados.
  • Estas instrucciones generan:
  • A
  • B
  • C
  • S
  • T
  • B

Ejemplo

  • Entity TRISTATE is
  • port (A, B, C, : in std_logic; S : out std_logic );
  • end TRISTATE
  • Architecture ARCHI of TRISTATE is
  • begin
  • S <= A when C = ‘0’ else ‘Z’;
  • S <= B when C = ‘1’ else ‘Z’;
  • end ARCHI;
  • A
  • C
  • B
  • S

Entity is

  • Entity is
  • port (A, B : in std_logic_vector(15 downto 0);
  • C : in std_logic;
  • S : out std_logic_vector(15 downto o));
  • end TRISTATE;
  • Architecture ARCHI of TRISTATE is
  • begin
  • S<=A when C=‘0’ else “ZZZZZZZZZZZZZZZZ”;
  • S<=B when C=‘1’ else “ZZZZZZZZZZZZZZZZ”;
  • End ARCHI;
  • C
  • B[ 15:0]
  • S[ 15:0]
  • A[ 15:0]

Asignación de señales por selección. with - select

  • Ejemplo:
  • with signal_x select
  • signal_y <= valor_y1 when “00”,
  • valor_y2 when “01”,
  • valor_y3 when “10”,
  • valor_y4 when others;

Ejemplo 2:

  • Ejemplo 2:
  • architecture archi of muxAndNot is
  • begin
  • with SEL select
  • S <= A when “00”,
  • B when “01”,
  • C when “10”,
  • D when others;
  • T <= not B,
  • end archi
  • A
  • B
  • C
  • D
  • B
  • SEL[1:0]
  • T
  • S

Ciclos con: for - in – to - generate

  • Sintaxis:
  • LABEL: for i in enteroA to enteroB generate
  • --Instrucciones concurrentes
  • end generate;
  • i No necesita declararse previamente y no puede modificarse su valor dentro del ciclo.
  • enteroA y enteroB definen el número de iteraciones.
  • LABEL es de uso obligatorio.
  • generate puede ajustarse empleando range.

Decodificador. Hexadecimal – 7 Segmentos.

  • Tabla de verdad:
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • 1
  • 1
  • 1
  • 0
  • 0
  • 0
  • 1
  • 1
  • 1
  • 1
  • 1
  • F
  • 1
  • 1
  • 1
  • 1
  • 0
  • 0
  • 1
  • 0
  • 1
  • 1
  • 1
  • E
  • 1
  • 0
  • 1
  • 1
  • 1
  • 1
  • 0
  • 1
  • 0
  • 1
  • 1
  • D
  • 0
  • 1
  • 1
  • 1
  • 0
  • 0
  • 1
  • 0
  • 0
  • 1
  • 1
  • C
  • 1
  • 1
  • 1
  • 1
  • 1
  • 0
  • 0
  • 1
  • 1
  • 0
  • 1
  • B
  • 1
  • 1
  • 1
  • 0
  • 1
  • 1
  • 1
  • 0
  • 1
  • 0
  • 1
  • A
  • 1
  • 1
  • 0
  • 1
  • 1
  • 1
  • 1
  • 1
  • 0
  • 0
  • 1
  • 9
  • 1
  • 1
  • 1
  • 1
  • 1
  • 1
  • 1
  • 0
  • 0
  • 0
  • 1
  • 8
  • 0
  • 0
  • 0
  • 0
  • 1
  • 1
  • 1
  • 1
  • 1
  • 1
  • 0
  • 7
  • 1
  • 1
  • 1
  • 1
  • 1
  • 0
  • 1
  • 0
  • 1
  • 1
  • 0
  • 6
  • 1
  • 1
  • 0
  • 1
  • 1
  • 0
  • 1
  • 1
  • 0
  • 1
  • 0
  • 5
  • 1
  • 1
  • 0
  • 0
  • 1
  • 1
  • 0
  • 0
  • 0
  • 1
  • 0
  • 4
  • 1
  • 0
  • 0
  • 1
  • 1
  • 1
  • 1
  • 1
  • 1
  • 0
  • 0
  • 3
  • 1
  • 0
  • 1
  • 1
  • 0
  • 1
  • 1
  • 0
  • 1
  • 0
  • 0
  • 2
  • 0
  • 0
  • 0
  • 0
  • 1
  • 1
  • 0
  • 1
  • 0
  • 0
  • 0
  • 1
  • 0
  • 1
  • 1
  • 1
  • 1
  • 1
  • 1
  • 0
  • 0
  • 0
  • 0
  • 0
  • g
  • f
  • e
  • d
  • c
  • b
  • a
  • D
  • C
  • B
  • A

Decodificador BCD – 7 Segmentos

  • with BCDIN select
  • display <= “0000000” when x “0”,
  • “0000000” when x “1”,
  • “0000000” when x “2”,
  • “0000000” when x “3”,
  • “0000000” when x “4”,
  • “0000000” when x “5”,
  • “0000000” when x “6”,
  • “0000000” when x “7”,
  • “0000000” when x “8”,
  • “0000000” when x “9”,
  • “0000000” when x “a”,
  • “0000000” when x “b”,
  • “0000000” when x “c”,
  • “0000000” when x “d”,
  • “0000000” when x “e”,
  • “0000000” when x “f ”,
  • “0000000” when others;

CONFIGURACION

  • La configuración es como una lista de partes, especificando cual arquitectura debe ser usada para cada entidad del diseño.
  • Permitir una configuración por default permite que el código sea más portable.

CONFIGURACION

  • Es el enlace entre cada nivel de la jerarquía, y la especificación de cual arquitectura es la que debe ser usada

COMPILACION

  • Después de que se ha escrito el código de VHDL en un archivo de texto, el código es analizado para determinar si tiene errores de sintaxis, y se crea un archivo binario.
  • Este proceso es realizado por unas de las herramientas para compilación y por otras herramientas para análisis.

MAPEO DE BIBLIOTECAS

  • Las herramientas de simulación y síntesis de VHDL acceden a un archivo que tiene un mapa de los nombres de las bibliotecas de VHDL con los directorios físicos en la computadora.
  • VHDL también permite definir una biblioteca llamada WORK como la biblioteca en la cual las unidades de diseño son compiladas sino se especifica una biblioteca

Como se ejecuta una simulación

Mecanismo de Cola

  • En un momento dado dentro de una simulación se generan 2 colas:
    • Cola de señales a actualizar
    • Cola de procesos a ejecutar
  • Ejecución del proceso

Proceso puesto en la cola

  • Cuando una señal es actualizada en un punto específico del tiempo de simulación, todos los procesos que son sensitivos a esa señal son puestos en una cola de procesos en ejecución.
  • Actualización de la señal
  • Ejecución del proceso
  • Instrucción: M <= B;
  • B actualizada
  • Proceso puesto en la cola

Una cola de señales actualizadas

    • Las señales que son asignadas en cada proceso no son actualizadas inmediatamente después de que el proceso se suspende, son puestas en una cola de señales actualizadas.
    • Las señales son actualizadas cuando todos los procesos han sido ejecutados.

Ciclo Delta

    • Como resultado de la actualización de las señales, otros procesos pueden ser ejecutados en la cola de procesos en ejecución.
    • Un ciclo que cubre esta secuencia es conocido como un ciclo Delta.
  • Actualización de la señal
  • Ejecución del proceso

Ejecución sobre el tiempo

Múltiples deltas en cada punto de tiempo de simulación

    • Varios ciclos delta en una simulación
    • En cada punto del tiempo de simulación se ejecuta el ciclo delta, hasta que no haya mas asignaciones o procesos en ejecución
  • Actualización de la señal
  • Ejecución del proceso
  • Actualización de la señal
  • Ejecución del proceso
  • Tiempo de simulación
  • Avanza a la siguiente actividad

La cláusula “after”

    • La asignación de una señal es colocada en una cola de “señales actualizadas” en un tiempo en el futuro, en lugar del tiempo actual
  • Tiempo de simulación
  • Z <= A after 5ns;
  • 5 ns

La cláusula “wait for”

  • Tiempo de simulación
  • Z <= A;
  • wait for 5 ns;
  • 5 ns
  • Z puesta en esta cola
1   2   3   4   5   6


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal