VHDL

VHDL es un lenguaje de definición de circuitos. V de Very High Speed Integrated Circuit y HDL de Hardware Definition Language. Es decir, no es un lenguaje de programación, sino de definición. Mediante VHDL se definen las interfaces con circuitos, así como su comportamiento interno.

Poco a poco se pueden reutilizar componentes previamente hechos. También la comunidad comparte diseños, llamados cores, con los que puedes reutilizarlos, modificarlos, etc. Esta escalabilidad se puede seguir, el único límite será la complejidad que puede alcanzar el diseño.

Humildemente aquí iré dejando apuntes relacionados con VHDL, mientras que me voy reciclando y poniendo al día, con la mente en las FPGAs.. 😉

VHDL: uniendo circuitos, un sumador completo de 4 bits

2019-08-08 - Categorías: VHDL
VHDL port map haciendo un sumador completo de 4 bits.

Sigo poniéndome al día en electrónica digital, diseñando circuitos digitales. Así que aquí vuelvo con otro code-kata para hacer un sumador de varios bits. Para este sumador reutilizo un componente previamente hecho, diseñando un sumador completo de 4 bits.

Es decir, en un post anterior escribí un sumador completo simple de 1 bit. Ahora con la instrucción de VHDL llamada port map, podemos enlazar tantos componentes como necesitemos en circuitos más grandes. Usando port map es la forma que tenemos de escalar tanto como queramos, todos los circuitos que queramos en sistemas digitales cada vez más grandes.

Continuar leyendo..

VHDL: restador completo de 1 bit

2019-08-05 - Categorías: VHDL
VHDL restador completo de 1 bit
VHDL restador completo de 1 bit.

Aquí dejo otro code-kata en VHDL, ahora para construir un restador completo de 1 bit. Recibe 3 entradas y saca 2 salidas. Es muy parecido al sumador completo del post anterior.

La tabla de verdad de este circuito es la siguiente:

Acarreo de entradaABAcarreo de salidaResta
00000
00111
01001
01100
10011
10110
11000
11111

El código fuente del restador

Las primeras pruebas construyendo sin simplificar, después el simplificado:

-- Sumador completo de 1 bit
library IEEE;
use IEEE.std_logic_1164.all;

entity oneBitFullSubstractor is
    port (
        sub, carryOut : out std_logic;
        a, b, carryIn : in std_logic
    );
end entity;

architecture arch of oneBitFullSubstractor is

    signal auxInVect : std_logic_vector (2 downto 0);

begin

    auxInVect(2) <= carryIn;
    auxInVect(1) <= a;
    auxInVect(0) <= b;

    sub <= '0' when auxInVect = "000" else
        '1' when auxInVect = "001" else
        '1' when auxInVect = "010" else
        '0' when auxInVect = "011" else
        '1' when auxInVect = "100" else
        '0' when auxInVect = "101" else
        '0' when auxInVect = "110" else
        '1';

    carryOut <= '0' when auxInVect = "000" else
        '1' when auxInVect = "001" else
        '0' when auxInVect = "010" else
        '0' when auxInVect = "011" else
        '1' when auxInVect = "100" else
        '1' when auxInVect = "101" else
        '0' when auxInVect = "110" else
        '1';

end architecture;

El restador simplificado

De nuevo, utilizando las tablas de Karnaugh llegamos a simplificar el código anterior a este siguiente:

-- Sumador completo de 1 bit
library IEEE;
use IEEE.std_logic_1164.all;

entity oneBitFullSubstractor is
    port (
        sub, carryOut : out std_logic;
        a, b, carryIn : in std_logic
    );
end entity;

architecture arch of oneBitFullSubstractor is
begin

    sub <= (carryIn and (not a) and (not b))
        or ((not carryIn) and (not a) and b)
        or (carryIn and a and b)
        or ((not carryIn) and a and (not b));

    carryOut <= (carryIn and (not a))
        or (carryIn and b)
        or ((not a) and b);

end architecture;

El banco de pruebas

Igual que con el sumador, nos sirve casi el mismo banco de pruebas. Sólo cambio el componente y la nomenclatura de alguna variable:

-- Restador completo de 1 bit
library IEEE;
use IEEE.std_logic_1164.all;

entity oneBitFullSubstractor_tb is
end entity;

architecture arch of oneBitFullSubstractor_tb is

    component oneBitFullSubstractor is
        port (
            sub, carryOut : out std_logic;
            a, b, carryIn : in std_logic
        );
    end component;

    signal testInVect : std_logic_vector (2 downto 0);
    signal testSubOut, testCarryOut : std_logic;

begin

    unit_under_test: oneBitFullSubstractor port map (
        sub => testSubOut,
        carryOut => testCarryOut,
        carryIn => testInVect(2),
        a => testInVect(1),
        b => testInVect(0)
    );

    generate_signals : process
    begin
        testInVect <= "000"; wait for 10 ns;
        testInVect <= "001"; wait for 10 ns;
        testInVect <= "010"; wait for 10 ns;
        testInVect <= "011"; wait for 10 ns;
        testInVect <= "100"; wait for 10 ns;
        testInVect <= "101"; wait for 10 ns;
        testInVect <= "110"; wait for 10 ns;
        testInVect <= "111"; wait for 10 ns;
        wait;
    end process;

end architecture;

Si todo ha ido bien, al visualizar las señales de entrada y salida, tanto con el circuito normal como con el simplificado, se tiene que ver algo como la imagen del principio.


VHDL: sumador completo de 1 bit

- Categorías: VHDL
VHDL sumador completo 1 bit.

Traigo un code-kata de un circuito digital. Se trata de un sumador completo de 1 bit. Es decir, es un circuito con 3 entradas y 2 salidas. Las tres entradas son: un acarreo, y los dos bits que vamos a sumar.

Continuar leyendo..

VHDL: multiplexor de 4 a 1 con selección de 2 bits

2019-08-02 - Categorías: VHDL
VHDL multiplexor 4 a 1 son selección de 2 bits

Code-kata para generar un circuito de un multiplexor. En este caso es un multiplexor que recibe 4 señales de entrada y las encauza en una salida eligiendo con otras dos señales de entrada cuál tiene que encauzar a la salida.

Es decir, los 2 pins de entrada para seleccionar nos permiten 4 posibilidades: 00, 01, 10 y 11. Esto nos permite, suponiendo que tenemos 4 señales de entrada x0, x1, x2 y x3; que si seleccionamos 00 en la salida saldrá la señal de entrada x0, si ponemos 01 saldrá la señal x1, si ponemos 10 saldrá la señal x2 y si ponemos en selección 11 saldrá la señal de entrada x3 por la única salida que hay.

Continuar leyendo..

VHDL: decodificador BCD de 4 bits para display de 7 segmentos

- Categorías: VHDL
VHDL decodificador 4 bits para display de 7 segmentos.

Code-kata para mostrar en un display de siete segmentos números en binario que van desde el 0 al 9. Es un sencillo circuito que se puede encadenar con otros para mostrar los dígitos que sean necesarios. Esto es lo que se llama un decodificador BCD de 4 bits para un display de 7 leds, en este caso.

No tiene mucho que explicar simplemente que es un circuito que convierte las señales de entrada de 4 bits en una señal de salida de 7 bits. Las de entrada son números en binario del 0 al 9. Mientras que las de salida simplemente encienden o apagan los segmentos para pintar el número que toque.

Continuar leyendo..

VHDL: decodificador 4 a 16

2019-07-31 - Categorías: VHDL
GTKWave señales del banco de pruebas de un decodificador 4 a 16.

Otro code-kata traigo ahora. Se trata de un decodificador que tiene 4 pines de entrada y 16 de salida. Le falta la señal de habilitado/deshabilitado. Puede servir para activar 16 cosas, en función a una señal de entrada de 4 bits, como paso intermedio en el viaje de la información por los circuitos, etc..

Continuar leyendo..

VHDL: los ladrillos básicos; and, or, not, nand, nor, xor y xnor

- Categorías: VHDL
VHDL puertas lógicas básicas.

Dejo aquí un code-kata a modo de apunte de consulta. Se trata de un código no sintetizable, ya que no tiene entradas ni salidas, sólo es a modo de pruebas. Una entidad sin entradas ni salidas que asigna concurrentemente señales x y para visualizar en GTKWave los resultados de las puertas lógicas.

Sin muchas explicaciones, es más sencillo leer el código. Tenemos dos partes principales en los ficheros .vhd: la del entity y la del architecture que define el entity.

Continuar leyendo..

VHDL: diseñando hardware con software libre

2019-07-28 - Categorías: VHDL

Con este post comienzo con una serie de apuntes sobre el lenguaje de definición de hardware VHDL. Para los nuevos, VHDL no es un lenguaje de programación, sino un lenguaje de definición. Me explico, no lo confundamos o hablaremos piedras. Algunos lo llaman Very Hight Difficult Language 😀 difícil es, pero en realidad las siglas vienen del VHSIC (Very High Speed Integrated Circuit) y HDL (Hardware Description Language).

Resumiendo, VHDL es un lenguaje de descripción de hardware, con el que podemos definir y probar hardware, antes de pedir su fabricación a mayor escala. También podemos inyectar el diseño generado en FPGAs para usar directamente en los prototipos, ya viendo después si conviene sintetizarlo o no, y con qué tecnología.

Continuar leyendo..

© 2020 JnjSite.com - MIT license

Sitio hecho con WordPress, diseño y programación del tema por Jnj.