VHDL, hur och med vad?

[TomasL]

Skulle behöva skapa några VHDL-modeller.
Vad använder man och hur (kanske blir självklart när man har korrekt programvara).
För bekvämlighetens skull vore det bra om det funkade under Win7-64.

[Krille Krokodil]

Vi körde Alteras gamla utvecklingsmiljö MAX+PLUS II i skolan, det är bara ett par 10 MB stort.
Deras nya Quartus II kan man också ladda ner och köra fritt men det är en koloss på GB med
ett överflöd av funktioner att gå vilse i.

http://www.altera.com/download/legacy/m ... index.html
http://www.eit.lth.se/fileadmin/eit/cou ... _ht_13.pdf

Edit: "Student edition" är det man skall ladda ner, jag har för mig att simulatorn saknas i det vanliga versionen.

[Andax]

ISE WebPack från Xilinx är också gratis. Dock GB stort att tanka ner.

[stekern]

Frågeställningen är lite knaper, du säger att du vill skapa VHDL modeller, men inte vad du skall använda de någonstans. Det är ungefär som att fråga "Jag vill skapa C program, vad använder man och hur". Svaret på båda frågorna är "i en text editor", sen är det fortgående svaret vad du skall använda för verktyg beroende på var implementationen skall användas någonstans.

Skall det användas i en fpga/cpld, så är givetvis tillverkarens verktyg att rekommendera. Skall du bara simulera så finns det en uppsjö av simulatorer, med alteras verktyg följer det med en 'crippled' version av modelsim och xilinx har sitt Isim. Sen finns det ghdl som är ett opensource alternativ (eller icarus om du skippar VHDL och använder verilog istället).

Vill du skapa nätlistor för att studera så kan du göra det i vilket som av de ovannämnda verktygen från xilinx eller altera. Det finns även detta intressanta projekt: http://www.clifford.at/yosys/about.html Men, det är återigen för verilog.

[TomasL]

Så här är det:
Mitt CAD-program kan använda VHDL-modeller i MixedMode simulering.
Vad jag vill göra är att skapa modeller av de grindarna jag använder i mitt lilla datorprojekt, så jag kan köra en simulering av ALU'n.

[blueint]

Låter intressant med ett CAD program som hanterar VHDL. Klarar det nätlistor typ SPICE för kretskort också?

[stekern]

Så här är det:
Mitt CAD-program kan använda VHDL-modeller i MixedMode simulering.
Vad jag vill göra är att skapa modeller av de grindarna jag använder i mitt lilla datorprojekt, så jag kan köra en simulering av ALU'n.

Aha, det ställer ju frågan i en helt ny dager, råden att installera flera gigabyte av verktyg från Xilinx eller Altera kan ju direkt kasseras då.
Som jag nämnde i mitt förra inlägg, allt du behöver för att skapa VHDL-modeller är en text editor. Jag föredrar emacs, men jag kan nästan lova
att vilken din favoriteditor än är så finns det säkert syntax-highlighting etc för VHDL till den med.

Så, för att komma till själva kärnan av frågan, hur man skriver VHDL-kod.
Eftersom du nämner ditt datorprojekt (jag följer det med intresse) med en ALU, kan vi ju börja med ett exempel på en simpel sådan.

Kod: Markera allt

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity alu is
  port(
    a           : in std_logic_vector(7 downto 0);
    b           : in std_logic_vector(7 downto 0);
    op          : in std_logic_vector(1 downto 0);
    result      : out std_logic_vector(7 downto 0)
  );
end;

architecture rtl of alu is

  constant ALU_OR         : std_logic_vector(1 downto 0) := "00";
  constant ALU_AND        : std_logic_vector(1 downto 0) := "01";
  constant ALU_XOR        : std_logic_vector(1 downto 0) := "10";
  constant ALU_ADD        : std_logic_vector(1 downto 0) := "11";

begin

  with op select
    result <= a or b                                      when ALU_OR,
              a and b                                     when ALU_AND,
              a xor b                                     when ALU_XOR,
              std_logic_vector(unsigned(a) + unsigned(b)) when ALU_ADD,
              x"00"                                       when others;
end rtl;

Jag la till den lite mer komplicerade '+' operationen för att ge ett exempel på hur VHDLs starkt typade
system kräver att du 'cast'ar a och b först från std_logic_vector till unsigned och sedan resultatet tillbaka
till std_logic_vector. Detta är nödvändigt eftersom '+' operatorn inte är tillåten att användas direkt med en
std_logic_vector.

Bara för att vidareutveckla, så delar jag med mig av en testbänk till den ovanstående ALUn.
Den kan snyggas till genom refaktorera koden i den, men jag valde att skriva allt i ett stycke för tydlighetens skull.

Kod: Markera allt

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_textio.all;
use ieee.numeric_std.all;
use std.textio.all;

entity alu_tb is
end;

architecture behaviour of alu_tb is
  constant ALU_OR         : std_logic_vector(1 downto 0) := "00";
  constant ALU_AND        : std_logic_vector(1 downto 0) := "01";
  constant ALU_XOR        : std_logic_vector(1 downto 0) := "10";
  constant ALU_ADD        : std_logic_vector(1 downto 0) := "11";

  component alu is
    port(
      a         : in std_logic_vector(7 downto 0);
      b         : in std_logic_vector(7 downto 0);
      op        : in std_logic_vector(1 downto 0);
      result    : out std_logic_vector(7 downto 0)
    );
  end component;

  signal a      : std_logic_vector(7 downto 0);
  signal b      : std_logic_vector(7 downto 0);
  signal op     : std_logic_vector(1 downto 0);
  signal result : std_logic_vector(7 downto 0);

begin

  alu0 : alu
    port map (
      a      => a,
      b      => b,
      op     => op,
      result => result
    );

  process
    variable l : line;
  begin
    a <= x"aa";
    b <= x"5f";

    op <= ALU_OR;
    wait for 10 ns;
    write(l, string'("Test 'or':"));
    writeline (output, l);
    hwrite(l, a);
    write(l, string'(" or "));
    hwrite(l, b);
    write(l, string'(" = "));
    hwrite(l, result);
    writeline (output, l);

    op <= ALU_AND;
    wait for 10 ns;
    write(l, string'("Test 'and':"));
    writeline (output, l);
    hwrite(l, a);
    write(l, string'(" and "));
    hwrite(l, b);
    write(l, string'(" = "));
    hwrite(l, result);
    writeline (output, l);

    op <= ALU_XOR;
    wait for 10 ns;
    write(l, string'("Test 'xor':"));
    writeline (output, l);
    hwrite(l, a);
    write(l, string'(" xor "));
    hwrite(l, b);
    write(l, string'(" = "));
    hwrite(l, result);
    writeline (output, l);

    op <= ALU_ADD;
    wait for 10 ns;
    write(l, string'("Test 'add':"));
    writeline (output, l);
    hwrite(l, a);
    write(l, string'(" + "));
    hwrite(l, b);
    write(l, string'(" = "));
    hwrite(l, result);
    writeline (output, l);

    wait;
  end process;

end behaviour;

För att simulera detta kan man använda ghdl (som jag nämnde i ett tidigare inlägg)

Kod: Markera allt

ghdl -a --ieee=synopsys alu.vhd
ghdl -a --ieee=synopsys alu_tb.vhd
ghdl -e --ieee=synopsys alu_tb
ghdl -r --ieee=synopsys alu_tb

Utskriften från detta skall då bli:

Kod: Markera allt

Test 'or':
AA or 5F = FF
Test 'and':
AA and 5F = 0A
Test 'xor':
AA xor 5F = F5
Test 'add':
AA + 5F = 09

Hoppas det hjälper dig att komma igång, det är alldeles för lite trådar som handlar om hårdvarubeskrivande språk på EF