Quartus II und VHDL (ich bin verwirrt)

Hallo Kest!

Danke für die schnelle Antwort!

Ich hätte jetzt nicht gedacht, dass das 
work.edge_triggered_Dff(behavioral) etwas mit ModelSIM zu tun hat. Aus 
dem Buch lese ich heraus, dass das einfach nur das Verzeichnis (work) 
und das Entity in diesem Verzeichnis (edge_triggered_Dff) ist.

Über die Sache mit den Components bin ich gerade am Lesen in dem Buch. 
Bis jetzt habe ich das so verstanden, dass die Components so eine Art 
"Prototypen" sind. D.h., dass es eine so etwas wie eine Entity 
Deklaration ist. Allerdings ohne Architeture. Das Hilft mir jetzt hier 
auch nicht so richtig weiter, da ich ja schon gerne mein Entity (also 
mit Architecture) in die aktuelle Architektur einbinden möchte.

Gruß
Maik

@ Maik Ritter

>Angefangen hat das mit den "wait" Statements, die Quartus so nicht
>gefressen hat (man muss stattdessen eine Sensitivitätsliste an den
>Process in Klammern hängen.)

Wait geht nur in Testbenches für Simulationen. Es ist nicht 
synthetisierbar.

>Nun bin ich dabei eine Architecture zu schreiben, die ein externes
>Entity einbinden soll. In dem Buch steht dann da, dass das so geht:

>bit0 : entity work.edge_triggered_Dff(behavioral)
>    port map (d0,clk,clr,q0);

>Das haut bei mir aber so nicht hin. Ich bekomme immer einen
>Syntaxfehler, kann aber keinen Syntaxfehler finden. Nun denke ich, dass
>das so in Quartus vielleicht auch wieder nicht funktioniert.

Das ist die akademische Schreibweise. Quartus ist jedoch ein wenig 
zuvorkommender.
Wenn deine Components als Datei im Projekt eingebunden sind, kann man 
die ganz normal mit demNamen instanziieren, ohne das work. davor.

>Quartus ist nicht unbedingt ein VHDL-Compiler.

Es ist eine komplette Entwicklungsumgebunf incl. VHDL-Compiler.

>Um  entity work.edge_triggered_Dff(behavioral) verwenden zu können,
>brauchst Du zunächst mal ein work-Verzeichnis, welches Du mit ModelSIM
>erstellen kannst. Vielleicht geht es ja auch mit Quartus, glaube ich
>jedoch nicht.

Modelsim und Quartus sind verschiedene Sachen!

Modelsim: Simulator
Quartus: Entwicklungsumgebung mit Eingabe- und Synthesewerkzeugen

>Ich hätte jetzt nicht gedacht, dass das
>work.edge_triggered_Dff(behavioral) etwas mit ModelSIM zu tun hat. Aus

Hat es auch nicht.

>Bis jetzt habe ich das so verstanden, dass die Components so eine Art
>"Prototypen" sind. D.h., dass es eine so etwas wie eine Entity
>Deklaration ist.

Componets allgemein sind Modlue, genauso wie Funktionsbibliotheken ind 
Programmiersprachen wie C oder Pascal.

MfG
Falk

Hallo Falk!

Ist mal wieder so eine Sache, die ich alleine nicht in den Griff bekomme 
. .

Hier ist mal ein kleines Programm, das funktioniert:

1

library ieee;

2

use ieee.std_logic_1164.all;

3

4

entity shift_test is

5

  port (t0, t1, t2, t3, clk : in std_logic;

6

      input, output : out std_logic_vector (2 downto 0));

7

end entity shift_test;

8

9

architecture shifttester of shift_test is

10

  type sr_array is array (8500 downto 0) of std_logic_vector(2 downto 0);

11

  signal sr : sr_array;

12

  signal merker_t : std_logic_vector (2 downto 0) := b"000";

13

  signal merker_l : std_logic_vector (2 downto 0) := b"000";

14

  signal merker : std_logic := '0';

15

  signal merker_output : std_logic := '0';

16

  signal clk_out : std_logic := '0';

17

18

begin

19

20

  process (clk)

21

    variable cnt : integer range 0 to 30000;

22

    variable clk_on : std_logic := '0';

23

  begin

24

    if (clk'event and clk = '1') then

25

      if (cnt = 29999) then

26

        if (clk_on = '0') then

27

          clk_on := '1';

28

          clk_out <= '1';

29

          cnt := 0;

30

        else

31

          clk_on := '0';

32

          clk_out <= '0';

33

          cnt := 0;

34

        end if;

35

      else

36

        cnt := cnt + 1;

37

      end if;

38

    end if;

39

  end process;

40

41

  process (clk_out)

42

  begin

43

    if (clk_out'event and clk_out = '1') then

44

      sr(8500 DOWNTO 1) <= sr(8499 DOWNTO 0);

45

46

      if (merker_l(0) = '0' and merker_l(1) = '0' and merker_l(2) = '0') then

47

        merker_l <= sr(8500);

48

      end if;

49

50

      if (t0 = '0') then

51

        merker_t(0) <= '1';

52

      end if;

53

      if (t1 = '0') then

54

        merker_t(1) <= '1';

55

      end if;

56

      if (t2 = '0') then

57

        merker_t(2) <= '1';

58

      end if;

59

60

      if (t3 = '0' and merker = '0') then

61

        merker <= '1';

62

        sr(0) <= merker_t;

63

      end if;

64

65

    end if;

66

67

  end process;

68

69

  input <= merker_t;

70

  output <= merker_l;

71

72

  entity shift_test.clk_devider(clkdevider)

73

    port map (clk => clk_in, clk_out => clkin);

74

end architecture shifttester;

Jetzt würde ich gerne den ersten Process in ein eigenes Entity mit 
Architecture packen, und dieses dann als Strukturbeschreibung einbinden.

Habe ich auch versucht. Klappt aber nicht, so wie es im Buch steht (mit 
oder ohne .work)

Hast du vielleicht mal wieder einen Tip parat?

Gruß
Maik

@ Maik Ritter

Leg zwei Dateien in deinem Projekt an

------------------------------------------------------------------------ 
--------
-- DATEI A

library ieee;
use ieee.std_logic_1164.all;

entity shift_test is
  port (t0, t1, t2, t3, clk : in std_logic;
      input, output : out std_logic_vector (2 downto 0));
end entity shift_test;

architecture shifttester of shift_test is

-- Component declaration

Component clk_gen is
  port (clk : in std_logic;
        clk_out : out std_logic);
end Component;

  type sr_array is array (8500 downto 0) of std_logic_vector(2 downto 
0);
  signal sr : sr_array;
  signal merker_t : std_logic_vector (2 downto 0) := b"000";
  signal merker_l : std_logic_vector (2 downto 0) := b"000";
  signal merker : std_logic := '0';
  signal merker_output : std_logic := '0';
  signal clk_out : std_logic := '0';

begin

-- Component instanciation
-- muss immer mit einen Label beginnen

l_comp1: clk_gen port map
       (clk     => clk,
        clk_out => clk_out);

  process (clk_out)
  begin
    if (clk_out'event and clk_out = '1') then
      sr(8500 DOWNTO 1) <= sr(8499 DOWNTO 0);

      if (merker_l(0) = '0' and merker_l(1) = '0' and merker_l(2) = '0') 
then
        merker_l <= sr(8500);
      end if;

      if (t0 = '0') then
        merker_t(0) <= '1';
      end if;
      if (t1 = '0') then
        merker_t(1) <= '1';
      end if;
      if (t2 = '0') then
        merker_t(2) <= '1';
      end if;

      if (t3 = '0' and merker = '0') then
        merker <= '1';
        sr(0) <= merker_t;
      end if;

    end if;

  end process;

  input <= merker_t;
  output <= merker_l;

  entity shift_test.clk_devider(clkdevider)
    port map (clk => clk_in, clk_out => clkin);
end architecture shifttester;

------------------------------------------------------------------------ 
--------



>Jetzt würde ich gerne den ersten Process in ein eigenes Entity mit
>Architecture packen, und dieses dann als Strukturbeschreibung einbinden.

------------------------------------------------------------------------ 
--------
-- Datei B

library ieee;
use ieee.std_logic_1164.all;

entity clk_gen is
  port (clk : in std_logic;
        clk_out : out std_logic);
end entity clk_gen;

architecture arch1 of clk_gen is

begin

  process (clk)
    variable cnt : integer range 0 to 30000;
    variable clk_on : std_logic := '0';
  begin
    if (clk'event and clk = '1') then
      if (cnt = 29999) then
        if (clk_on = '0') then
          clk_on := '1';
          clk_out <= '1';
          cnt := 0;
        else
          clk_on := '0';
          clk_out <= '0';
          cnt := 0;
        end if;
      else
        cnt := cnt + 1;
      end if;
    end if;
  end process;

end architecture arch1;


------------------------------------------------------------------------ 
--------

MfG
Falk

P.S. Arbeite besser mit Signalen, nicht Variablen. Da kann man sich 
gerade als Anfänger leicht ins Knie schiessen.

Hallo Falk!

Danke, jetzt geht es. Was bei mir gefehlt hat war die "component" 
Deklaration am Anfang der Architektur in Datei A. Leider steht das so 
auch nicht bei mir im Buch drin. . . .
Ich habe das Gefühl, das VHDL Theorie und ein reales Problem im FPGA 
lösen manchmal ganz schön weit auseinander liegen.

Ist der Grund dafür, das VHDL am Anfang wirklich nur für 
Simulatiuonszwecke entwickelt wurde? Weil es ja nun sehr viele 
Sprachkonstrukte zu geben scheint, die nicht "synthetisiert" werden 
können.
Bedeutet das dann, dass, wenn man ein VHDL Lehrbuch hat noch ein VHDL 
Praxisbuch benötigt, um die Dinge zu erfahren, die im realen FPGA Design 
nicht möglich sind? Gibt es so eon Buch, und wenn ja, wie heißt es?

Ich würde mich echt freuen, wenn es eine Gegenüberstellung von Dingen 
geben würde, die in VHDL zwar definiert sind, die aber nicht 
"synthesefähig" sind. Gibt es so etwas?

Gruß und Danke!

Maik

@ Maik Ritter

>Ich habe das Gefühl, das VHDL Theorie und ein reales Problem im FPGA
>lösen manchmal ganz schön weit auseinander liegen.

Der Unterschied zwischen Theorie und Praxis ist in der Praxis grösser 
als in der Theorie. ;-)

>Ist der Grund dafür, das VHDL am Anfang wirklich nur für
>Simulatiuonszwecke entwickelt wurde? Weil es ja nun sehr viele
>Sprachkonstrukte zu geben scheint, die nicht "synthetisiert" werden
>können.

Kann sein.

>Bedeutet das dann, dass, wenn man ein VHDL Lehrbuch hat noch ein VHDL
>Praxisbuch benötigt, um die Dinge zu erfahren, die im realen FPGA Design
>nicht möglich sind? Gibt es so eon Buch, und wenn ja, wie heißt es?

Gute Frage. Aber da ist der Markt wohl leider SEHR dünn gesät. Keine 
Ahnung.

>"synthesefähig" sind. Gibt es so etwas?

Dito. Keine Ahnung.

MfG
Falk

Falk Brunner wrote:
> Component clk_gen is
>   port (clk : in std_logic;
>         clk_out : out std_logic);
> end Component;

In VHDL `93 soll man die Component-Deklaration auch weglassen koennen. 
Kommen die Synthesetools von X und A damit zurecht?

@  Andreas Schwarz

>In VHDL `93 soll man die Component-Deklaration auch weglassen koennen.
>Kommen die Synthesetools von X und A damit zurecht?

Bei X AFAIK nein.

MFG
Falk