Maxwert eines Integer-Ranges

[Jean (Gast)]

Hallo Leute,

habe folgendes Problem:

signal cnt : natural range 0 to 23;

process
begin
    wait until clk = '1';

    if cnt < 23 then
       cnt <= cnt + 1;
    else
       cnt <= 0;
    end if;
end process;

Nun möchte ich aber die Abfrage des Maximal-Wertes verallgemeinern. Wie
kann ich den Maximalwert eines Integer-Ranges abfragen ?

process
begin
    wait until clk = '1';

    if cnt < cnt'max then               -- Gibt es so natürlich nicht
       cnt <= cnt + 1;
    else
       cnt <= 0;
    end if;
end process;

Gruß,
Jean

[Klaus F. (kfalser)]

cnt'high

[Klaus F. (kfalser)]

Doch cnt'right !

Beitrag "Integer range Maximum wiedergeben"

Google is your friend (oder doch nicht) !

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

Hilft alles nichts...
> cnt'right
Prefix of attribute 'right must be an array object.
> cnt'high
Prefix of attribute 'high must be an array object.

Nicht mal ein Subtyp bringt uns hier weiter.
Also: Konstante oder Generic anlegen und darauf abfragen.

[SuperWilly (Gast)]

... und wer lesen kann, ist klar im Vorteil.

Das Attribut 'right kann man nicht auf integer-Signale anwenden.


VG,
SuperWilly

[Harald F. (hfl)]

Mal was ganz was anderes. Bist Du sicher dass Du den Prozesss korrekt 
formuliert hast? Keine sensitivity list, keine event-Abfrage? Nix?? Was 
soll denn das werden am Ende der Tage?

[Jean (Gast)]

Am Ende des Tages wird es ein getakteter Prozess.

Gruß,
Jean

[Jean (Gast)]

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

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

architecture a of tst is
signal cnt : natural range 0 to 23 := 0;
begin
tst <= '1' when cnt = 23 else '0';

process
begin
    wait until clk = '1';

    if cnt < 23 then
       cnt <= cnt + 1;
    else
       cnt <= 0;
    end if;
end process;

end a;

SynplifyPro-Ergebnis siehe Anhang

Gruß,
Jean

[Jean (Gast)]

... und in Modelsim ...


Gruß,
Jean

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

> wait until clk = '1';
Hier wird in der Simulation auch eine Änderung von 'H' nach '1' als ein 
Takt angesehen. Aber die Synthesetools verstehen zum Glück, was gemeint 
ist... ;-)

Besser wäre
wait until rising_edge(clk);

[Jean (Gast)]

Ich weiss, bin aber schreibfaul ;O)

Gruß,
Jean

[Jean (Gast)]

>Hier wird in der Simulation auch eine Änderung von 'H' nach '1' als ein
>Takt angesehen.

Die Simulatin zeigt etwas anderes, siehe Anhang.

Gruß,
Jean

[Jean (Gast)]

Sorry, Du hast Recht, siehe Anhang

Gruß,
Jean

[Mathi (Gast)]

Um genau zu sein:

wait until clk = '1';

ist die Beschreibung für ein Latch.

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

> wait until clk = '1';
Nein.

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

Uups.. da ging was schief....

> Um genau zu sein: wait until clk = '1';
> ist die Beschreibung für ein Latch.
Das "until" alleine bei einemwait wartet schon auf einen Wechsel des 
angegebene Signals.

wait until clk;
wäre dann auf die fallende und steigende Flanke sensitiv.

Zusammen mit clk='1' heißt das dann ausgeschrieben:
wait until clk'event and clk='1';

[Harald F. (hfl)]

Wow, der Thread hat sich aber schnell entwickelt. Ihr seid eine aktive 
Tippgemeinschaft!
Als ich allerdings die Frage gestellt habe, was das am Ende werden soll, 
meinte ich eher: im FPGA. Dort gibt es keine getakteten Prozesse und 
auch keine Wechsel von 'H' nach '1' (Eins). Verilog und VHDL sind 
Hardwarebeschreibungssprachen, und auch wenn sie den Komfort der 
Abstraktion bieten, am Ende werden Gatter (ok, LUTs) und D-Flipflops 
daraus. Etwas anderes gibt es im FPGA nicht, und daher sollte man etwas 
anderes auch nicht beschreiben. Keine RS-Flipflops, keine JK-Flipflops, 
keine Latches. Daher hat Lothar wie immer Recht. wait until clk'event 
and clk='1' (VHDL) bzw. always @(posedge clk) (Verilog) und die Pendants 
für die fallende Flanke sind die einzigen zulässige Konstrukte, auch 
wenn die Synthesetools nachsichtig sind.

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

> Verilog und VHDL sind Hardwarebeschreibungssprachen,
Sie sind Systembeschreibungssprachen. Nur ein sehr sehr kleiner Teil des 
Sprachumfangs von VHDL kann z.B. tatsächlich umgesetzt werden. So was 
Einfaches geht z.B. schon nicht:  b <= a after 10 ms;

> am Ende werden ... D-Flipflops daraus.
> Etwas anderes gibt es im FPGA nicht
Oh doch: z.B. kann jedes FF eines S3 Slices alternativ in einem 
Latch-Modus betrieben werden.

> im FPGA. Dort gibt es keine getakteten Prozesse
Echt?
Mein primärer Fokus ist, Prozesse zu takten... ;-)

>  keine Wechsel von 'H' nach '1' (Eins).
Bei ASICs kann es das durchaus geben.

> am Ende werden Gatter (ok, LUTs) und D-Flipflops
> daraus. Etwas anderes gibt es im FPGA nicht,
In alten FPGAs gab es auch interne Tristate-Busse. Und damit eventuell 
auch Wechsel von 'H' nach '1'.

Wie heißt es so schön: Man lernt nie aus. ;-)

[Harald F. (hfl)]

Hallo Lothar,

ich weiß schon, dass es früher mal tristate-Signale in den FPGAs und 
ASICs gegeben hat. Bin schließlich schon lange genug dabei, durfte auch 
mal ein ASIC entwickeln (0.8u) und habe auch einen tristate-Bus im ASIC 
verwendet. Aber willst Du den jungen Burschen das heute noch beibringen? 
Die sollen lieber synchrone Designs im FPGA machen und keine 
Schweinereien. Deshalb erzähle ich solche Details lieber nicht. In einem 
Punkt hast Du auf alle Fälle recht: Man lernt nie aus. Mir war nicht 
bewusst, dass sich Xilix noch den Luxus des Latches erlaubt. Altera 
macht das mit einer kombinatorischen Rückführung, weshalb die Timing 
Analyse dort regelmäßig verzweifelt. Und wenn ich's mir recht überlege, 
wer weiß, ob Xilinx das nicht auch so macht und nur anders darstellt. 
Denn das können die wirklich klasse, da muss ich immer wieder 
applaudieren. Last but not least erlaube mir bitte noch eine 
Klugscheißerei: Verilog ist eine Hardwarebeschreibungssprache, war nie 
als etwas anderes gedacht, und daher heißt das Referenzdokument auch 
"Verilog Hardware Description Language Reference Manual".

[Jean (Gast)]

wenn es eine latch-beschreibung äre, dann würde synplifyPRO das auch als 
solches implementieren und einen feedback-mux ansetzen, es werden aber 
D-FFs implementiert. Mentor-Precision implementiert ebenfalls D-FFs. Was 
gibt es noch an relevanten Synthese-Tools ? Ach ja XST ... kann ich 
leider nichts zu sagen.

@ Mathi: also nicht behauptungen aufstellen, sondern direkt mal mit 
deinem synthese-tool ausprobieren und berichten.

Gruß,
Jean

[Jean (Gast)]

> und die Pendants für die fallende Flanke sind die "inzigen zulässige 
>Konstrukte, auch wenn die Synthesetools nachsichtig sind.

Die Synthesetools sind schon sehr restriktiv, da scheint

wait until clk = '1'

gar nicht so abwegig zu sein ;- )

Gruß,
Jean

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

Jean schrieb:
> Ach ja XST ... kann ich leider nichts zu sagen.
XST macht aus dieser Beschreibung (entsprechend dem in VHDL definierten 
Verhalten von wait until) die erwarteten D-Flipflops.

Jean schrieb:
> da scheint  wait until clk = '1'  gar nicht so abwegig zu sein ;- )
Es impliziert aber (genauso wie  "if clk'event and clk='1' then...")
z.B. bei einem Übergang von 'H' (oder auch 'Z' mit einem Pullup) nach 
'1' einfach einen Takt, wo eigentlich keiner ist. Zum Glück gibt es 
diesen Übergang innerhalb heutiger FPGAs aber nicht mehr, und deshalb 
kann diese Beschreibung durchaus verwendet werden, wenn man sich des 
Hintergrunds bewusst ist.

[Harald F. (hfl)]

-> Jean
Sorry, wenn ich nochmal nachhake. Würdest Du dir die Mühe machen, einen 
Algorithmus in C zu schreiben, sagen wir mal einen Algorithmus für die 
Texterkennung in Bildern, und ihn dabei so zu formulieren, dass er auf 
einem ARM-Controller läuft, aber nicht auf dem PC? Hoffentlich nicht. 
Solche Sachen (Algorithmen, Modelle) sollten doch wiederverwendbar sein. 
Wie man so etwas formuliert, sollte von der Zielarchitektur und den 
Synthesetools unabhängig sein. Die verwendete Sprache sollte 
ausschlaggebend sein, sonst nichts. Und da heißen die Konstrukte nunmal 
wait until clk'event and clk='1' (VHDL) bzw. always @(posedge clk) 
(Verilog) (plus die Pendants für fallende Flanke).
Sorry nochmal, ist nur meine Meinung zu dem Thema.

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

Formal korrekt:
wait until clk'event and clk='1' and clk'last_value='0';
Oder kürzer:
wait until rising_edge(clk);

Aus der Library std_logic_1164:

FUNCTION rising_edge  (SIGNAL s : std_ulogic) RETURN BOOLEAN IS
BEGIN
    RETURN (s'EVENT AND (To_X01(s) = '1') AND 
                        (To_X01(s'LAST_VALUE) = '0'));
END;

FUNCTION falling_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN IS
BEGIN
    RETURN (s'EVENT AND (To_X01(s) = '0') AND 
                        (To_X01(s'LAST_VALUE) = '1'));
END;

Hier eine kurze Betrachtung zum Thema:
Beitrag "CLK'event oder rising_edge(clk)"
http://www.mikrocontroller.net/articles/VHDL#CLK.3D.271.27_and_CLK.27event_oder_rising_edge.28.29.3F

[Mathi (Gast)]

Oh nein.
Da habe ich was falsch verstanden mit der wait-Beschreibung.
Habe das im LRM nachgelesen wie das zu interpretieren ist.

Aber dazu dann die Frage:
 Wie beschreibe ich dann ein Latch mit einem wait?

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

> Wie beschreibe ich dann ein Latch mit einem wait?
Ich würde sagen: das geht nicht für die Synthese.
Nachdem sowas ja ein Latch darstellt:

  process (le, din) begin
    if le='1' then
      dout <= din;
    end if;
  end process;

und die Sensitivliste durch ein wait ersetzt werden könnte:

  process begin
    wait until le='0' or le='1' or din='0' or din='1'; -- ersetzt die Sensitivliste
    if le='1' then
      dout <= din;
    end if;
  end process;

kommt zwar die Simulation damit zurecht, aber die Synthese stolpert, 
weil sie aus einem wait einen Takt machen will:

Bad condition in wait statement, or only one clock per process.

[Mathi (Gast)]

Danke!
Aber die Kosequenz daraus wäre ja, dass wait und sensitivity-list, für 
die Synthese, nicht äquivalent in der Beschreibungsmächtigkeit sind.

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

> Aber die Kosequenz daraus wäre ja, dass wait und sensitivity-list, für
> die Synthese, nicht äquivalent in der Beschreibungsmächtigkeit sind.
Jain.
Die Konsequenz daraus ist, dass VHDL als Sprache viel mehr zulässt, als 
die Synthesewerkzeuge in Hardware abzubilden in der Lage sind...

Zur Erinnerung: vor nicht allzulanger Zeit konnte ein Synthesewerkzeug 
mit wait allgemein überhaput nichts anfangen.

[Marcus H. (mharnisch)]

Harald Flügel schrieb:
> Die verwendete Sprache sollte ausschlaggebend sein, sonst
> nichts. Und da heißen die Konstrukte nunmal wait until clk'event and
> clk='1' (VHDL) bzw. always @(posedge clk) (Verilog) (plus die
> Pendants für fallende Flanke).

Was VHDL angeht, sind die legalen Möglichkeiten weitaus vielfältiger
als gemeinhin angenommen. Siehe IEEE 1076.6, sec 6.1.3 und, was die
Verwendung des wait-statement angeht, insbesondere
6.1.3.2. Typischerweise werden nicht alle Möglichkeiten von sämtlichen
Synthesewerkzeugen unterstützt. Es ist aber schon aus Gründen der
Lesbarkeit empfehlenswert, gängige Konstrukte (rising_edge)
anzuwenden.

Der Verilog Ausdruck posedge (und in ähnlicher Form negedge) reagiert
im Übrigen ebenfalls auf diverse Signalwechsel: "A posedge shall be
detected on the transition from 0 to x, z, or 1, and from x or z to 1"

--
Marcus

[Harald F. (hfl)]

Wow, ein wirklich heißer Tread. Ein Entwickler stellt eine Frage über 
den Maximalwert eines Integer-Ranges und die Cracks überbieten sich mit 
Details über die richtige Syntax getakteter Prozesse. Dabei hat Jean das 
Hauptproblem ganz klar benannt:

Lothar:
Besser wäre
wait until rising_edge(clk);

Jean:
Ich weiss, bin aber schreibfaul ;O)

Tja Jean, dann nimm Verilog! Ich hoffe sehr, mit diesem unqualifizierten 
off-topic Einwurf den Tread neu zu befeuern. ;-)

[D. I. (Gast)]

In einer etwas moderneren Vorlesung die mit utner auch VHDL als 
Bestandteil hat, haben wir mal untersucht was man noch synthetisieren 
könnte wenn die Tools es könnten.
Umgekehrt sind wir auf den Schluss gekommen das folgende Sachen einfach 
nicht oder kaum machbar sind:

- while-schleifen
- rekursion
- zeitangaben wie after 5ms

alles andere könnte implementiert werden, wie z.b. mehrere wait 
anweisungen in einem prozess. Aber die Toolhersteller haben sich ihre 
Kundschaft schon zurecht erzogen :)

[Marcus H. (mharnisch)]

D. I. schrieb:
> In einer etwas moderneren Vorlesung[...]
> Umgekehrt sind wir auf den Schluss gekommen das folgende Sachen einfach
> nicht oder kaum machbar sind:
>
> - while-schleifen
> - rekursion

Warum sollten while Schleifen nicht (oder kaum) synthetisierbar sein? 
Jede Schleife, deren Abbruchbedingung statisch ist, ist prinzipiell auch 
synthetisierbar. Das gilt daher in vielen Fällen auch für Rekursion. Ich 
habe schon vor >10 Jahren erfolgreich Rekursion in VHDL mit Synopsys DC 
verwendet. (Interessanterweise war Rekursion in diesem Fall sogar nötig, 
da sich DC weigerte, eine Schleife zu akzeptieren)

Ein Teil der Logikoptimierung basiert auf der Umwandlung von Schleifen 
in rekursive Strukturen, mit der u.U. Verzögerungen besser ausbalanciert 
werden können.

--
Marcus

[D. I. (Gast)]

Darum geht es, wenn vorher die Bedingung statisch ist.

Auch wenn die Mengen gleich groß sind, mir fielen mehr nicht statische 
als statische Anwendungsfälle ad hoc ein

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

> alles andere könnte implementiert werden, wie z.b. mehrere wait
> anweisungen in einem prozess.
Das geht zumindest ansatzweise:
http://www.lothar-miller.de/s9y/archives/47-wait-im-Prozess.html