Prozesskommunikation / Flankenerkennung

[Johannes Scherle (Gast)]

Hallo alle,

ich habe eine Frage zur Flankenerkennung bzw. der Kommunikation zwischen 
Prozessen.
Folgendes Szenario:
Ein Prozess, sensitiv auf ein Sensor Eingangssignal, das einen high / 
low Pegel liefert. Dieser soll die Anzahl der Kanten auf diesem Signal 
liefern, also mit jeder Flanke um eins erhöhen und bei vier wieder auf 
Null zurücksetzen. Das Signal edgeCounter wird nur in diesem Prozess 
beschrieben.

process (oneorzero)
  --constant maxEdges : natural := 4;
  begin
     if (blockOccured = true) then
      if (edgeCounter = 4) then
       --edgeCounter <= 0;
    edgeCounter <= (others => '0');
       else
       edgeCounter <= edgeCounter + 1;
     end if;
    elsif (blockOccured = false) then
      --edgeCounter <= 0;
     edgeCounter <= (others => '0');
   end if;
  end process;

In einem anderen, synchronen Prozess möchte ich das Signal edgeCounter 
lesen und das Signal blockOccured, vom typ boolean schreiben.

Quartus synthetisiert mir das ohne zu meckern. Wenn ich das jedoch das 
Signal Tap Tool benutze und mir das ganze damit anschaue, sieht man, 
dass der edgeCounter scheinbar willkürlich mit jeder Taktflanke der 
Clock des synchronen Prozesses auf irgendwelche Werte gesetzt wird.

Jemand ne Idee?

Viele Grüße

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

Johannes Scherle schrieb:
> Quartus synthetisiert mir das ohne zu meckern.
Echt? Such mal im Synthesereport nach "combinational loop" oder 
"combinatorial loop". Das hast du mit dem edgeCounter nämlich gebaut:
http://www.lothar-miller.de/s9y/categories/36-Kombinatorische-Schleife

Und die Simulation wird sicher nicht stimmen, weil das ein 
kombinatorischer Prozess ist, bei dem blockOccured und der edgeCounter 
in der Sensitivliste fehlen...

> Dieser soll die Anzahl der Kanten auf diesem Signal liefern,
> also mit jeder Flanke um eins erhöhen
Also einfach zählen.
Zähler werden immmer mit Flipflops aufgebaut.
Flipflops brauchen immer einen Takt.
Und Takte solltest du im Idealfall genau einen (in Zahlen 1) haben.
Erst dann wird das Design so richtig schön einfach...

[Schlumpf (Gast)]

Hallo Johannes,

Lothar hat es ja schon gesagt:
Das, was du da beschreibst, geht eigentlich gar nicht und es ist ein 
Wunder, dass die Synthese es "gefressen" hat.
WAS sie allerdings daraus gebaut hat, wird nicht das sein, was du dir 
vorgestellt hast.
Stichwort Combinatorial Loop wurde ja schon genannt.

Prozesse sind sensitiv auf einen Zustandswechsel eines Signals in deren 
Sensitivity-Liste. ABER das sollte man niemals dazu verwenden, um eine 
Flankenerkennung zu bauen.

Überlege dir, wie eine Flankenerkennung und ein Zähler in "echter" 
Hardware aussehen würde (mit FlipFlops und Gattern).
Und genau das beschreibst du dann in VHDL.

eine Flankenerkennung macht man, indem man das zu analsysierende Signal 
durch zwei Register schiebt und die beiden Register auf "Ungleichheit" 
überprüft. Dann entsteht an diesem Vergleicher für einen Systemtakt lang 
eine "1", wenn eine Flanke vorliegt. Dieses Signal kann dann als 
Steuereingang (Enable) für einen synchronen Zähler dienen.

[Uwe (Gast)]

> also mit jeder Flanke um eins erhöhen
Mit jeder ? Also mit jeder positiven Flanke und jeder negativen ?
Man muß sich im klearen sein was das für Bauelemte im FPGA drinne sind 
und einfach mal kurz überschlagen ob man aus diesen das gewünschte 
selber bauen könnte (wenn man der Synthetisierer wär).
Brauchst du das wirklich, reicht es nicht nur eine Art Flanken zu zählen 
und an das Ergebnis hinten noch ein weiteres 0 Bit drazupacken (also mal 
2 zu nehmen)?
Wenn du es wirklich brauchst dann mußt du einen Zähler machen der die 
positiven Flaken Zählht un einen der die negativen zählt und beide 
addieren.

[Schlumpf (Gast)]

Uwe schrieb:
> Wenn du es wirklich brauchst dann mußt du einen Zähler machen der die
> positiven Flaken Zählht un einen der die negativen zählt und beide
> addieren.

Wieso das denn? Er will doch nur die Flanken des Eingangssignals 
erkennen und zählen.
Zählerfrequenz hoch genug wählen und dann mit bei steigendenden Flanke 
des Systemtakts den Zähler inkrementieren, wenn die Flankenerkennung des 
Eingangssignals Meldung macht ;-)

Also Eingangssignal steuert über eine Flankenerkennungslogik das EN des 
Counters, dessen Register mit dem Systemtakt versorgt werden.

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

Uwe schrieb:
> Brauchst du das wirklich, reicht es nicht nur eine Art Flanken zu zählen
> und an das Ergebnis hinten noch ein weiteres 0 Bit drazupacken (also mal
> 2 zu nehmen)?
> Wenn du es wirklich brauchst dann mußt du einen Zähler machen der die
> positiven Flaken Zählht un einen der die negativen zählt und beide
> addieren.
Zweimal Murks.

Dabei ist es so einfach:
Johannes Scherle schrieb:
> Dieser soll die Anzahl der Kanten auf diesem Signal liefern
Also was schnarchlangsames im Vergleich mit den 50MHz, die üblicherweise 
als Takt für ein FPGA herhalten müssen. Das heißt frei nach Kochrezept:
1. Einsynchronisieren
2. Flanke erkennen
3. Zählen
4. Auswerten
Frei nach 
http://www.lothar-miller.de/s9y/categories/35-Einsynchronisieren würde 
ich also etwa so anfangen:

signal insr  : std_logic_vector(2 downto 0);
:
process begin    -- keine Sensitivliste bedeutet: keine FALSCHE Sensitivliste
   wait until rising_edge(clk); -- alles hört auf den 50MHz Takt

   -- Schieberegister zum Einsynchronisieren
   insr <= insr(1 downto 0) & input;

   if (insr(2)/= insr(1)) then   -- irgendeine Flanke von input
     if (blockOccured = true) then
       if (edgeCounter = 4) then -- wenn der Zähler auf 4 zählt, dann hat er eins zuviel gezählt: 0,1,2,3,4 sind 5 Schritte
        --edgeCounter <= 0;  -- jaja, wenn der Zähler ein Integer wäre, dann ginge das
         edgeCounter <= (others => '0');
       else
         edgeCounter <= edgeCounter + 1;
       end if;
     elsif (blockOccured = false) then
      -- edgeCounter <= 0;   -- siehe oben
       edgeCounter <= (others => '0');
     end if;
      
   end if;
end process;