Probleme mit einfachem VHDL-Modul

[Fabian H. (Firma: Technische Universität Berlin) (brein)]

Hallo Leute,

ISE gibt mir eine Fehlermeldung mit der ich absolut nichts anfangen 
kann.

Was habe ich getan?

Ich habe ein Modul mit folgender Entity erstellt:

entity mod27 is
    Port ( C : in  STD_LOGIC;
        testClock : in STD_LOGIC;
           Bits : out  STD_LOGIC_VECTOR (4 downto 0));
end mod27;

Das Modul soll lediglich die Clock hochzählen und ausgeben. Bei 27 soll 
der Ausgang wieder auf 0 gesetzt werden. Getaktet wird es mit dem 50MHz 
Boardtakt, dass das Modul auf 1Hz runterteilt.

In der Simulation funktioniert alles wunderbar.

Das zugehörige UCF-File sieht wie folgt aus:

NET "C" LOC = "B8";
NET "Bits<0>" LOC = "J14";
NET "Bits<1>" LOC = "J15";
NET "Bits<2>" LOC = "K15";
NET "Bits<3>" LOC = "K14";
NET "Bits<4>" LOC = "E16";

-------------------------
Nun ist der Fehler, während des Schreibens verschwunden. So kann ich 
leider die Fehlermeldung nicht reinschreiben.

Das macht die Sache aber nicht wirklich besser.

Wie Ihr sicherlich vermutet, reagiert das Board nicht.
Es müssten eigentlich LD0..LD4 die Bits ausgeben. Tun sie aber nicht.

Fehler gibt es sicher viele.

Was habe ich alles falsch gemacht?

Und warum gibt es eigentlich nirgends ein vernünftiges Tutorial zu 
diesem Thema? Das ist doch äußerst wichtig bei der Synthese.
http://www.mikrocontroller.net/articles/UCF-Dateien ist ja nicht gerade 
ausführlich. Es zeigt ja noch nicht mal, dass die Angaben in 
Anführungsstriche gesetzt werden müssen. Selbst Entwurf
digitaler Schaltungen und Systeme ISBN 3486589873 schweigt sich da 
gänzlich aus. Unverständlich.

Vielen Dank für eure Hilfe
Fabian

[Fabian H. (Firma: Technische Universität Berlin) (brein)]

Ach!
Wie kann ich Einglänge (testClock) hart auf GND oder VCC setzen???

[Haro (Gast)]

>schweigt sich aus
Das liegt daran, dass die Bücherschreiber immer nur dasselbe schreiben 
und die Details gerne weglassen.  Was du prinzipiell alles machen musst, 
musst Du dir eben langsam erarbeiten.

Zum UCF: Du brauchts gfs ein clock constraint, die locs scheinen ok

Was bei Dir konkret nicht geht, kann hier aber keiner beantworten, weil 
du keinen code gepostet hast. Wo ist der Zähler?

[Fabian H. (Firma: Technische Universität Berlin) (brein)]

@ Haro

Zähler???
Was meinen Sie damit?

Hier aber erstmal der Code:

----------------------------------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    10:47:25 11/29/2011 
-- Design Name: 
-- Module Name:    mod27 - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;

-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
-- use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity mod27 is
    Port ( C : in  STD_LOGIC;
        testClock : in STD_LOGIC;
           Bits : out  STD_LOGIC_VECTOR (4 downto 0));
end mod27;

architecture Behavioral of mod27 is

  COMPONENT clkdiv1hz
   PORT ( Clk_in : in  STD_LOGIC;
          Clk_out : out  STD_LOGIC);
  END COMPONENT;

  -- SIGNAL BoardClock : STD_LOGIC;
  SIGNAL Clk1Hz : STD_LOGIC;

begin
  FrequDiv1Hz: clkdiv1hz PORT MAP (
    Clk_in  => C,
    Clk_out => Clk1Hz
  );

--Clk1Hz <= testClock;

  modulo27: process (Clk1Hz, testClock)
  VARIABLE Count: INTEGER RANGE 0 to 27 := 0;
  begin
    Count := Count + 1;
    if (Count > 26) then
      Count := 0;
    end if;
    Bits <= conv_std_logic_vector(Count, 5);
  end process modulo27;
  
end Behavioral;

Das Clock-Modul

----------------------------------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    23:41:59 11/27/2011 
-- Design Name: 
-- Module Name:    clkdiv1hz - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity clkdiv1hz is
    Port ( Clk_in : in  STD_LOGIC;
           Clk_out : out  STD_LOGIC);
end clkdiv1hz;

architecture Behavioral of clkdiv1hz is
  Signal Clk_out_tmp: STD_LOGIC := '0';  -- Vorinitialisierung und zum auslesen des Ausgangs
begin

Clock_1Hz: process (Clk_in)
  VARIABLE Counter: integer := 0;      -- Taktzähler
Begin
  if rising_edge(Clk_in) then        -- Bei steigender Taktflanke
    Counter := Counter + 1;          -- inkrementiere Taktzähler
    if(Counter = 25000000) then      -- nach einer halben Sekunde
      Clk_out <= not Clk_out_tmp;    -- Toggle den Ausgang
      Clk_out_tmp <= not Clk_out_tmp;  -- Toggle ebenso das temp.-Signal
      Counter := 0;              -- resette den Counter für die nächste halbe Sekunde
    end if;
  end if;
End Process Clock_1Hz;

end Behavioral;

Prügel sind erlaubt. Was mich nicht umbringt macht mich klüger! ^^

Danke
Fabian

[Fabian H. (Firma: Technische Universität Berlin) (brein)]

Haro schrieb:
>...
>
> Zum UCF: Du brauchts gfs ein clock constraint, die locs scheinen ok
>
> ...

Keine Ahnung wie das funktionieren soll.

Laut dem Tutorial:
__
Taktdefinition

NET CLOCK        LOC = AA12;
NET CLOCK        TNM_NET = "CLOCK_50";
TIMESPEC         TS_CLOCK_50 = PERIOD CLOCK_50 50 MHz HIGH 50 %;
__

habe ich alles richtig gemacht. NET <Busname für CLOCK> LOC = <Pin>.

[Fabian H. (Firma: Technische Universität Berlin) (brein)]

Ich kann ehrlich gesagt, mit keinen dieser Warnungen was anfangen.

WARNING:MapLib:701 - Signal Bits<4> connected to top level port Bits<4> has been
   removed.
WARNING:MapLib:701 - Signal Bits<3> connected to top level port Bits<3> has been
   removed.
WARNING:MapLib:701 - Signal Bits<2> connected to top level port Bits<2> has been
   removed.
WARNING:MapLib:701 - Signal Bits<1> connected to top level port Bits<1> has been
   removed.
WARNING:MapLib:701 - Signal Bits<0> connected to top level port Bits<0> has been
   removed.

Hat keiner gesagt, dass er das tun soll.

WARNING:PhysDesignRules:367 - The signal <C_IBUF> is incomplete. The signal does
   not drive any load pins in the design.
WARNING:Par:288 - The signal C_IBUF has no load.  PAR will not attempt to route this signal.

Doch! Das Clock-Signal B8!

WARNING:Par:283 - There are 1 loadless signals in this design. This design will cause Bitgen to issue DRC warnings.

Siehe oben!

WARNING:PhysDesignRules:367 - The signal <C_IBUF> is incomplete. The signal does
   not drive any load pins in the design.

Kann jemand von euch was damit anfangen?
Ich verzweifle langsam an diesem Wahnsinn.
Die Arbeit bleibt liegen, nur weil nicht mal klar ist, welche Fehler es 
gibt, geschweige denn Lösungen.

Wäre super wenn mich hier jemand erleuchten kann.

Muss man sich mal Vorstellen, wie einfach das Programm ist. Was wird das 
nur, wenn es ein richtiges Projekt gibt.

Vielen Dank
Fabian

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

1. du brauchst die erstden paar Monate garantiert KEIN Variablen.
Siehe den Beitrag "Variable vs Signal"

2. Was sollte denn das hier geben:

  modulo27: process (Clk1Hz, testClock)
  VARIABLE Count: INTEGER RANGE 0 to 27 := 0;
  begin
    Count := Count + 1;
    if (Count > 26) then
      Count := 0;
    end if;
    Bits <= conv_std_logic_vector(Count, 5);
  end process modulo27;

Alles, was irgendwie irgendwas speichert (z.B. ein Zähler einen 
Zählerstand), muss in Flipflops abgebildet werden. Ein Flipflop hat 
einen Takt. Das, was du da beschrieben hat, kennt man als 
"kombinatorische Schleife": ein Zähler ohne Takt. Nein, es reicht nicht 
aus, wenn der Takt in der Sensitivliste steht. Diese Liste wird 
aussschliesslich von der Simulation verwendet!

> Wie kann ich Einglänge (testClock) hart auf GND oder VCC setzen???
http://www.lothar-miller.de/s9y/archives/81-Xilinx-ISE-Step-by-Step.html
Du definierst ein Signal, weist ihm im UCF einen Pin zu und schreibst 
dann
 spare <= '0';
Wenns mehrere sind, dann ist ein Vektor angebracht, da kannst du gleich 
alle restlichen Pins zuordnen und auf 0 setzen...
 spare <= (others=>'0');

> Kann jemand von euch was damit anfangen?

> Wäre super wenn mich hier jemand erleuchten kann.
Lies mal das:
http://www.lothar-miller.de/s9y/archives/80-Hello-World!.html
Und das:
http://www.lothar-miller.de/s9y/archives/61-Lauflicht.html

Und dann merk dir noch meine Postulate:

Ein Design (insbesondere ein Anfängerdesign) hat genau 1 Takt, 
der immer auf dieselbe Flanke aktiv ist. 
Es gibt keinen (und schon gar keinen asynchronen) Reset.
Externe Signale werden über 2 Flipflops einsynchronisiert.
Jede Abweichung von diesen Regeln muß fundiert begründet werden können.

Ein Takt ist alles, was mit   xxx_edge() oder 'event  zusammenhängt.

[Fabian H. (Firma: Technische Universität Berlin) (brein)]

Lothar Miller schrieb:
> 1. du brauchst die erstden paar Monate garantiert KEIN Variablen.
> Siehe den Beitrag "Variable vs Signal"

Das sehe ich anders. In Prozessen Variablen und in der Architecture 
Signale.
Signale haben auch nicht die arithmetischen Eigenschaften wie Variablen.
Wie bitte soll ich denn sonst hochzählen?
>
> 2. Was sollte denn das hier geben:
Was wird das wohl sein?
Ein Modulo 27 Counter. Wie es der Name schon sagt.
Er zählt den Eingang hoch und gibt ihn binärcodiert wieder aus. Bei 27 
wird zurückgesetzt.
Das einzige was ich falsch gemacht habe ist, dass ich nicht auf 
rising-edge reagiere, sondern auch auf die fallende Flanke.
Wird gleich ausgebessert.
>

>   modulo27: process (Clk1Hz, testClock)
>   VARIABLE Count: INTEGER RANGE 0 to 27 := 0;
>   begin
>     Count := Count + 1;
>     if (Count > 26) then
>       Count := 0;
>     end if;
>     Bits <= conv_std_logic_vector(Count, 5);
>   end process modulo27;
>

> Alles, was irgendwie irgendwas speichert (z.B. ein Zähler einen
> Zählerstand), muss in Flipflops abgebildet werden. Ein Flipflop hat
> einen Takt.

Ein RSFF hat zum Beispiel keinen Takt.

> Das, was du da beschrieben hat, kennt man als
> "kombinatorische Schleife": ein Zähler ohne Takt. Nein, es reicht nicht
> aus, wenn der Takt in der Sensitivliste steht. Diese Liste wird
> aussschliesslich von der Simulation verwendet!
Das war mir neu. Wird einem auch nicht gelehrt und steht auch in keinem 
der Bücher die ich bisher gelesen habe. Oder ich habe es überlesen.
Stammt wohl noch aus der Zeit als VHDL eine reine Simulationsprache war.

>
>> Wie kann ich Einglänge (testClock) hart auf GND oder VCC setzen???
> http://www.lothar-miller.de/s9y/archives/81-Xilinx-ISE-Step-by-Step.html
> Du definierst ein Signal, weist ihm im UCF einen Pin zu und schreibst
> dann
>  spare <= '0';
> Wenns mehrere sind, dann ist ein Vektor angebracht, da kannst du gleich
> alle restlichen Pins zuordnen und auf 0 setzen...
>  spare <= (others=>'0');
Danke. Werde ich mir gleich ansehen.
Aber schon traurig dass ich da einen GND-Ausgang erzeugen muss um dann 
einen weiteren Eingang auf GND setzten zu können. Das sieht dann 
bestimmt auch super aus, wenn ich von dem Modul ein Symbol erzeuge.
Warum sowas nicht geht, ist mir schleierhaft:

NET "PinToGND" LOC = "GND"
oder
... LOC = 0

Oder so ähnlich.

>
>> Kann jemand von euch was damit anfangen?
>
>> Wäre super wenn mich hier jemand erleuchten kann.
> Lies mal das:
> http://www.lothar-miller.de/s9y/archives/80-Hello-World!.html
> Und das:
> http://www.lothar-miller.de/s9y/archives/61-Lauflicht.html
Kommst Du mir jetzt wirklich mit Hello World???

>
> Und dann merk dir noch meine Postulate:
>

> Ein Design (insbesondere ein Anfängerdesign) hat genau 1 Takt,
> der immer auf dieselbe Flanke aktiv ist.
Ja, und? Habe ich das nicht?
> Es gibt keinen (und schon gar keinen asynchronen) Reset.
Was bitte ist ein (a)synchroner Reset und warum nicht?
> Externe Signale werden über 2 Flipflops einsynchronisiert.
Wie sieht das aus? http://www.lothar-miller.de/s9y/categories/35-Einsynchronisieren ? Wie soll ich die FFs in ein VHDL-Modul packen? Ist das letzte Gatter ein XOR?
Warum denn nur das?
Warum wird das einem nicht gelehrt?
> Jede Abweichung von diesen Regeln muß fundiert begründet werden können.
>

> Ein Takt ist alles, was mit   xxx_edge() oder 'event  zusammenhängt.

Vielen Dank für deine Mühen.
Fabian

[Fabian H. (Firma: Technische Universität Berlin) (brein)]

Und schon wieder stoße ich auf zwei Probleme.

Erstens habe ich wieder einen Fehler gemacht und zweitens gibt ISE dazu 
nur einen dusseligen Kommentar:

Um auf die Clock zu reagieren habe ich ein if-Statement hinzugefügt:

modulo27: process (Clk1Hz, testClock)
  VARIABLE Count: INTEGER RANGE 0 to 27 := 0;
  begin
    if rising_edge(Clk1Hz) or rising_edge(testClock) then -- <- !!! Line 60
      Count := Count + 1;
      if (Count > 26) then
        Count := 0;
      end if;
      Bits <= conv_std_logic_vector(Count, 5);
    end if;
  end process modulo27;

Die Fehlermeldung dazu:

line 60: unsupported Clock statement.

Aussagekräftig ist das nicht. Was bitte stört ihn daran? Und warum sagt 
er es nicht?
Nagut. Durch's Ausschlussverfahren kann ich sagen, es stört wohl, dass 
ich zweimal auf rising edge prüfe. Denn einzeln funktionieren die 
Statements.
Aber dumm ist das schon. Die Funktionen geben doch nur einen boolschen 
Wert zurück, den man behandeln kann, wie jeden anderen auch.
Und wie sonst soll ich auf zwei Takte prüfen? Ich muss ja sonst zwei 
Prozesse machen mit redundantem Inhalt. Warum zwingt mich VHDL zu solch 
einem schlechten Programmierstil?

Ich weiß dass Du gesagt hattest, ich solle nur einen Takt nehmen.
Aber aus der Praxis und hier aus praktischen Gründen nimmt man für Tests 
einen separaten Eingang. Ich meine, wie sonst soll ich den Teiler 
umgehen?
Ich habe keine Lust bei einer Simulation 50 Millionen Iterationen 
abwarten zu müssen, bis eine Sekunde simuliert wurde und das ganze 30 
mal, bis einmal der ganze Spaß durchlaufen wurde.
Die Simulation würde auf meinem Atom (was anderes habe ich im Moment 
einfach nicht) einen Tag dauern.

Gruß
Fabian

[Duke Scarring (Gast)]

Fabian Hoemcke schrieb:
> sondern auch auf die fallende Flanke.
Falsch. Bisher reagierst Du in Deinem module-Counter auf gar keine 
Flanke.

Fabian Hoemcke schrieb:
> Kommst Du mir jetzt wirklich mit Hello World???
http://de.wikipedia.org/wiki/Dunning-Kruger-Effekt

Duke

[Fabian H. (Firma: Technische Universität Berlin) (brein)]

ABER! Und das muss man auch mal sagen, es funktioniert jetzt.
War ja auch dumm von mir, nicht auf rising edges zu prüfen. So ist der 
Prozess sicher ständig mit einem affen Tempo durchlaufen wurden und die 
LEDs hatten noch nicht mal Zeit zum leuchten gehabt. Zu mindest glaube 
ich, dass das der Effekt war.
Aber mal ehrlich, wie bitte hätte ich von den oben genannten 
Fehlermeldungen (Warnings) auf diesen Fehler schließen sollen?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Fabian Hoemcke schrieb:
> Das sehe ich anders. In Prozessen Variablen und in der Architecture
> Signale.
Du hast den verlinkten Beitrag nicht wirklich gelesen und verstanden, 
oder?

Ich für meine Wenigkeit brauche und verwende Variablen nur in sehr 
ausgesuchten Situationen. Ich frage mich, warum du sie öfter 
brauchst...

> Signale haben auch nicht die arithmetischen Eigenschaften wie Variablen.
JEDE Rechenoperation, die du auf eine Variable anwenden kannst, kannst 
du ABSOLUT OHNE Einschränkung auf Signale anwenden.
Allerdings ist das sequentielle Verhalten von Signalen und Variablen 
in Prozessen anders. Letztendlich muß aber alles auf Hardware abgebildet 
werden können. Schon deshalb können sich Variable und Signale nicht so 
sehr unterscheiden.

> Kommst Du mir jetzt wirklich mit Hello World???
Offenbar ist das nötig, denn dann erübrigt sich die Frage:
> Wie bitte soll ich denn sonst hochzählen?


>> Alles, was irgendwie irgendwas speichert (z.B. ein Zähler einen
>> Zählerstand), muss in Flipflops abgebildet werden. Ein Flipflop hat
>> einen Takt.
> Ein RSFF hat zum Beispiel keinen Takt.
Zeig mir in deinem FPGA ein RS-Flipflop. Und wenn du das getan hast, 
dann sag mir, warum man keine asynchronen Flipflops verwenden soll. 
Also quasi, warum die Timinganalyse mit solchen Konstrukten Probleme 
hat...

> Stammt wohl noch aus der Zeit als VHDL eine reine Simulationsprache war.
Das war VHDL eigentlich nie. Schon der Name sagt was anderes aus: 
Description Language, Beschreibungssprache. Nicht wie Verilog, wo 
Verifizieren ein Namensbestandteil ist...

Nachtrag:
Fabian Hoemcke schrieb:
> ABER! Und das muss man auch mal sagen, es funktioniert jetzt.
Glückwunsch. Nur: du weißt nicht warum....

Fabian Hoemcke schrieb:
> Die Fehlermeldung dazu:line 60: unsupported Clock statement.
> Aussagekräftig ist das nicht. Was bitte stört ihn daran?
> Und warum sagt er es nicht?
Er sagt, dass er so eine Komponente nicht zur Verfügung hat. Klar: es 
gibt auch keine Flipflops mit 2 Takteingängen... :-o

Fabian Hoemcke schrieb:
> Das einzige was ich falsch gemacht habe ist, dass ich nicht auf
> rising-edge reagiere, sondern auch auf die fallende Flanke.
LOL...  :-D
Der war echt gut. Sieh dir mal das Hello-World-Beispiel genauer an...

[Fabian H. (Firma: Technische Universität Berlin) (brein)]

Duke Scarring schrieb:
> Fabian Hoemcke schrieb:
>> sondern auch auf die fallende Flanke.
> Falsch. Bisher reagierst Du in Deinem module-Counter auf gar keine
> Flanke.

Danke. Ist mir dann auch aufgefallen. Hast aber mit deinem Post 
verhindert, dass ich meinen noch bearbeiten konnte. ^^

Naja, Egal! So habe ich es angefügt.



>
> Fabian Hoemcke schrieb:
>> Kommst Du mir jetzt wirklich mit Hello World???
> http://de.wikipedia.org/wiki/Dunning-Kruger-Effekt
>
> Duke

Ich glaube, Du verkennst hier die Situation.
Ich kann nur auf das Wissen (meinetwegen auf das falsche Wissen) zurück 
greifen, dass ich habe. Da ich von der eigenen Fehlbarkeit ausgehe, 
stelle ich ja meine Vermutungen, Annahmen und Schlussfolgerungen zur 
Diskussion.
Wie etwa die Annahme, der Prozess würde nur bei Änderungen der Signale 
in der Sensitivity-List durchlaufen.
Oder anders gefragt, wo bitte habe ich die Leistungen anderer 
unterschätzt?

Gruß
Fabian

[Uwe (Gast)]

Man kann Programmiersprachen und "Hardwaresynthesesprachen" nicht 
miteinander Vergleichen. Du scheinst VHDL als Programmiersprache zu 
betrachten. Das sieht man an der art wie du Versuchst die Probleme zu 
lösen.
Du benötigst jedoch Digitaltechnik Kenntnisse FlipFlops, Logikgatter, 
Zustandsautomaten, Addierer, Multiplexer, Demultiplexer usw. was sind 
Setup und Hold Times usw. (halt die komplette Digitaltechnik bzw. 
Elektronik ). Ansonsten wird das nichts. Guck dir halt mal Datenblätter 
von alten CPUs, RAMS, SDRAMS an. Besonders die Timing Diagramme und 
versuche diese zu verstehen und bastel doch mal im Kopf (bzw. Papier) so 
ne CPU an nen SRAM mit Adresdecoder und allem.