VHDL Episódio 2 – Some quantos bits quiser

Esta postagem também está disponível em: InglêsEpisódios anteriores: http://joaopizani.hopto.org/2011/05/vhdl0 http://joaopizani.hopto.org/2011/06/vhdl1 Continuando o tutorial de VHDL, dessa vez acho que o código já não vai caber na tela de vocês… Em...

Esta postagem também está disponível em: Inglês

Episódios anteriores:

• http://joaopizani.hopto.org/2011/05/vhdl0
• http://joaopizani.hopto.org/2011/06/vhdl1

Continuando o tutorial de VHDL, dessa vez acho que o código já não vai caber na tela de vocês… Em compensação, esse episódio traz TRÊS novidades \o/ Hoje vamos programar e testar um somador de n-bits. Um somador que pode somar dois números com uma quantidade arbitrária de bits. A figura abaixo mostra exatamente a arquitetura que vamos implementar, é um somador “ripple-carry”:

Pela figura já dá pra notar qual vai ser o conceito mais importante abordado nesse episódio: a modelagem hierárquica, usando componentes. Ou seja, nós vamos montar a arquitetura de um somador de n bits usando um componente mais simples já descrito, o nosso somador de 1 bit do episódio anterior. Claro, tem mais novidades, mas primeiro vamos ao código :)

library ieee;
use ieee.std_logic_1164.all;

entity nBitAdder is
    Generic(nBits : integer := 8);
    Port(
        a : in std_logic_vector(nBits-1 downto 0);
        b : in std_logic_vector(nBits-1 downto 0);
        s : out std_logic_vector(nBits downto 0));
end nBitAdder;

architecture arch of nBitAdder is
    component fullAdder is
        Port(
            a    : in std_logic;
            b    : in std_logic;
            cin  : in std_logic;
            s    : out std_logic;
            cout : out std_logic);
    end component fullAdder;

    for leftmost: fullAdder use entity work.fullAdder;
    for rightmost: fullAdder use entity work.fullAdder;

    constant N_BITS : integer := nBits;

    signal sig_carryChain : array(1 to N_BITS-1) of std_logic;
begin
    -- rightmost bit
    rightmost: fullAdder
        port map(
            a    => a(0),
            b    => b(0),
            cin  => '0',
            s    => s(0),
            cout => sig_carryChain(1));

    -- middle bits
    middle: for i in 1 to N_BITS-2 generate
        adder: fullAdder
            port map(
                a    => a(i),
                b    => b(i),
                cin  => sig_carryChain(i),
                s    => s(i),
                cout => sig_carryChain(i+1));
    end generate middle;

    -- leftmost bit
    leftmost: fullAdder
        port map(
            a    => a(N_BITS-1),
            b    => b(N_BITS-1),
            cin  => sig_carryChain(N_BITS-1),
            s    => s(N_BITS-1),
            cout => s(N_BITS));
end arch;

O nosso somador “nBitAdder” tem uma novidade em sua seção “entity”: É a declaração de parâmetros genéricos. Os parâmetros que estão declarados nessa seção “Generic” têm seu valor definido em tempo de síntese, e, portanto, nosso somador não pode ser configurado “ao vivo” :), ou seja, enquanto o circuito funciona. Diferentes valores para os parâmetros alteram a síntese, e geram diferentes blocos resultantes. Muitas coisas úteis no design de hardware são feitas com esse tipo de parametrização, mas por enquanto o que nós queremos é simples:  ter um somador com entradas e saídas de tamanho genérico.

Agora, quanto à declaração das portas do nosso somador:

Port(
        a : in std_logic_vector(nBits-1 downto 0);
        b : in std_logic_vector(nBits-1 downto 0);
        s : out std_logic_vector(nBits downto 0));

Ele têm agora apenas duas entradas, que são os dois números a serem somados, cada um deles representado por “nBits” bits. O tipo de cada entrada é “std_logic_vector”, como nós já vimos no episódio anterior… A novidade é que a saída do nosso somador tem tamanho (nBits+1). isso, claro, pois a soma de dois números com n bits pode gerar um número de no máximo n+1 bits :)

A seção “architecture” já traz a grande novidade logo no início: a declaração do componente que vamos utilizar, nesse caso um fullAdder. Essa modelagem que utiliza componentes mais simples para montar os mais complexos é o famoso “bottom-up”, e esse estilo “Lego-like” de modelagem de hardware é um dos mais utilizados. A declaração de um componente nada mais é do que uma CÓPIA da seção entity desse componente, trocando a palavra “entity” por “component”. Isso parece repetitivo, e é mesmo :P Existem maneiras de não repetir essa declaração, mas isso virá mais para frente no tutorial, por enquanto, usar “component” é a maneira mais simples de fazer design hierárquico…

A constante N_BITS não é necessária, eu só usei pra mostrar como se declara uma constante, não merece grandes explicações… Já na linha de baixo vem a declaração do sinal “sig_carryChain”. Como nós vamos utilizar n fullAdders, vamos precisar de n-1 fios pra interconectar as entradas e saídas de carry deles. É por isso que declaramos um array de sinais std_logic:

signal sig_carryChain : array(1 to N_BITS-1) of std_logic;

Os índices do array vão de 1 até N_BITS-1, e portanto ele tem NBITS-1 elementos, onde cada elemento é do tipo std_logic.

Vamos então agora “montar” nosso LEGO, propriamente. Instanciamos o primeiro fullAdder, todos os outros serão instanciados de maneira semelhante.

rightmost: fullAdder
        port map(
            a    => a(0),
            b    => b(0),
            cin  => '0',
            s    => s(0),
            cout => sig_carryChain(1));

O primeiro bit da soma (de índice 0) é o mais à direita, o bit menos significativo. Conectamos as entradas desse fullAdder com as primeiras entradas do nosso nBitAdder, a saída com a primeira saída e a saída de carry desse primeiro fullAdder é o primeiro sinal na nossa cadeia de carry. De forma semelhante instanciamos o último bit, o mais à esquerda. A única diferença é que a saída de carry do último fullAdder é ligada ao bit “extra” (índice N_BITS) da saída.

Para instanciar os bits “intermediários” nós precisamos de uma abordagem mais “flexível” :) Nós precisamos instanciar mais NBITS-2 fullAdders. É esse tipo de “repetição controlada” de uma estrutura que o “generate” oferece.

    middle: for i in 1 to N_BITS-1 generate
        adder: fullAdder
            port map(
                a    => a(i),
                b    => b(i),
                cin  => sig_carryChain(i),
                s    => s(i),
                cout => sig_carryChain(i+1));
    end generate middle;

Cada um dos somadores do meio tem suas entradas e saídas ligadas às entradas e saídas de índice correspondente na entidade de n bits. A entrada de carry vem do sinal correspondente na cadeia de carry, e a saída de carry vai pro próximo sinal da cadeia. Tudo se encaixa como deve :)

Em termos de estilo de código não temos nenhuma novidade! Mas o código de hoje mostra como seu usa comentários em VHDL. Em VHDL só existe comentário de uma linha: toda linha começando em “–” (dois hífens consecutivos) é ignorada e considerada comentário.

Vamos então à parte emocionante do episódio: mostrar que o somador funciona, através de um testbench. Bem, dessa vez o código do próprio somador ficou grande, mas por incrível que pareça o código do testbench ficou relativamente pequeno, pois usamos os arrays que acabamos de aprender…

library ieee;
use ieee.std_logic_1164.all;

entity nBitAdder_testbench is
end nBitAdder_testbench;

architecture arch of nBitAdder_testbench is
    component nBitAdder is
        Generic(nBits : integer := 8);
        Port(
            a : in std_logic_vector(nBits-1 downto 0);
            b : in std_logic_vector(nBits-1 downto 0);
            s : out std_logic_vector(nBits downto 0));
    end component nBitAdder;

    for dut: nBitAdder use entity work.nBitAdder;

    constant N_BITS : integer := 4;

    signal sig_a : std_logic_vector(N_BITS-1 downto 0);
    signal sig_b : std_logic_vector(N_BITS-1 downto 0);
    signal sig_s : std_logic_vector(N_BITS downto 0);

    type testInputArray is array(0 to 7) of std_logic_vector(N_BITS-1 downto 0);
    type testOutputArray is array(0 to 7) of std_logic_vector(N_BITS downto 0);

    constant testInputsA : testInputArray := (
        "0000", "0001", "0100", "0101", "1000", "1001", "1100", "1101"); 
    constant testInputsB : testInputArray := (
        "1101", "1100", "1001", "1000", "0101", "0100", "0001", "0000");
    constant testOutputs : testOutputArray := (
        "01101", "01101", "01101", "01101", "01101", "01101", "01101", "01101");
begin
    dut: nBitAdder
        generic map(nBits => N_BITS)
        port map(
            a => sig_a,
            b => sig_b,
            s => sig_s);

    tb: process
    begin
        for i in 0 to 7 loop
            sig_a <= testInputsA(i);
            sig_b <= testInputsB(i);
            wait for 10 ns;
            assert (sig_s = testOutputs(i)) report "fail" severity failure;
        end loop;

        assert false report "All tests passed." severity failure;
    end process;

end arch;

Pronto! Acabou! Funciona!  Tá tudo bem agora.

Como sempre, pegue o código nesse pacote aqui: VHDL2 , compile o testbench, veja que tudo funciona e confira as formas de ondo no GTWake, surfe nas ondas do testbench! :P  Mais uma vez, o makefile empacotado junto com os arquivos VHDL vão te ajudar… Não se preocupe, tudo vai dar certo, pois esse tutorial tem o selo Entei de segurança: