Umschalten zwischen rising und falling edge

[Andi P. (jamaram90)]

Hallo,

folgenden Code habe ich mir überlegt:

process(Rx_buffer, Stop, reset)

variable s : std_logic_vector(n-1 downto 0);

begin

if reset = '1' then

 s := (others=> '0');
 
 elsif Rx_buffer(1) = '1' then
 
  if rising_edge(Stop) then
  
    s := q;
    signal_out_stop <= s;
    
  end if;
  
elsif Rx_buffer(1) = '0' then

  if falling_edge(Stop) then
  
    s := q;
    signal_out_stop <= s;
  end if;
  
end if;

end process;

Ich möchte quasi das es entscheidet, je nachdem was in Rx_buffer an der 
1. Bitstelle steht, ob 1 oder 0, es auf fallende oder steigende Flanke 
triggert.

Wenn ich den Code synthetisiere bekomme ich die Warnung:

Xst:3002 - This design contains one or more registers/latches that are 
directly incompatible with the Spartan6 architecture. The two primary 
causes of this is either a register or latch described with both an 
asynchronous set and asynchronous reset, or a register or latch 
described with an asynchronous set or reset which however has an 
initialization value of the opposite polarity (i.e. asynchronous reset 
with an initialization value of 1).


Kann mir jemand sagen wie ich das besser lösen kann damit es klappt. Ich 
hänge da jetzt schon eine Weile dran und verzweifle langsam. :-/

[Alexander F. (alexf91)]

Lösung: Löschen und neu anfangen.

Latches sind hier dein kleinstes Problem.
Nur mal als Beispiel: signal_out_stop ist ein Flipflop, das abwechselnd 
auf die fallende oder steigende Flanke des Taktes reagieren soll.

Ich gehe davon aus, dass Stop nicht wirklich ein Takt ist, sondern ein 
normales Signal, das du irgendwo erzeugst (oder gar ein Taster...).
So ein Signal verwendet man nicht als Takt, aber das ist genau das, was 
rising_edge() macht.
Was du mit der Variable vorhast, verstehe ich auch nicht, die erfüllt 
hier keinen Zweck, da der im Reset gesetzte Wert nie verwendet wird. 
Wenn du was speichern musst, dann verwende Signale.

Der bessere Weg ist, Stop mit einem richtigen Takt, der bestimmt auf 
deinem Board vorhanden ist, zu sampeln und je nachdem, welchen Wert 
Rx_Buffer(0) hat, eine Aktion bei einer steigenden oder fallenden Flanke 
auszulösen (nicht mit rising/falling_edge überprüfen).

Falls du kein VHDL Buch hast, dann kauf dir eins und arbeite das durch, 
hier fehlen Grundlagen.
VDHL-Synthese von Reichardt/Schwarz wird dir weiterhelfen.

[Andi P. (jamaram90)]

Die Variable s speichert den Wert eines Zählers zu dem das Signal Stop 
auftritt. Daher eben die Entscheidung ob steigende oder fallende Flanke.

[Alexander F. (alexf91)]

Alex P. schrieb:
> Die Variable s speichert den Wert eines Zählers zu dem das Signal Stop
> auftritt.

Das ist mir schon klar. Du verwendest diesen gespeicherten Wert aber 
immer nur direkt nach der Zuweisung.

signal_out_stop <= q;

reicht da auch.

Poste mal den gesamten Code, da liegt wohl noch einiges im Argen.

[Andi P. (jamaram90)]

Hier mal der gesamte Code. Es sollte dann noch ein weiterer Prozess 
hinzukommen der auf ein zweites Signal achtet und im Prinzip da auch 
wieder nach Einstellung über Rx_buffer(0) dann ob auf steigende oder 
fallende Flanke getriggert werden soll.

entity test is 
    
generic(n : integer := 16);       
  
 Port ( 
        
  clk     : in  STD_LOGIC;
  reset     : in std_logic;
  ce_i     : in   std_logic;
  Rx_buffer          : in std_logic_vector(1 downto 0);    
  Stop     : in std_logic;
         

         signal_out_stop : out std_logic_vector(n-1 downto 0); 
  ce_o  : out std_logic;
         Cout   : out std_logic_vector(n-1 downto 0)
        
       );
    
end test;


architecture Behavioral of test is

signal q : std_logic_vector(n-1 downto 0);


begin

P1: process(clk, ce_i, reset)

variable x : std_logic;

begin

if reset = '1' then

  q <= (others => '0');
  x := '0';
  
  
elsif ( clk'event and clk = '1' and ce_i = '1') then

  q <=  q + 1;
  x := '1';
  
end if;

ce_o <= x;

end process;

Cout <= q;


P2: process(Rx_buffer, Stop, reset)

variable s : std_logic_vector(n-1 downto 0);

begin

if reset = '1' then

 s := (others=> '0');
 
 elsif Rx_buffer(1) = '1' then
 
  if rising_edge(Stop) then
  
    s := q;
    signal_out_stop <= s;
    
  end if;
  
elsif Rx_buffer(1) = '0' then

  if falling_edge(Stop) then
  
    s := q;
    signal_out_stop <= s;
  end if;
  
end if;

end process;

end Behavioral;

[Forscher (Gast)]

für die Erkennung eines '0' zu '1' wechsel nimmt man kein rising_edge(),

rising_edge und falling_edge sind nur für die Beschreibung von 
flankengesteuerten (engl. edge triggered) FlipFlops zulässig.


Was du suchst ist keine Flanken Erkennung (edge-trigger) sondern eine 
Zustandswechselerkennung oder Übergangserkennung ("state-change" 
"Transition-detection").


Um einen '0'  auf '1'Signalwechsel zu erkennen schickst du das Signal 
durch ein D-FF

und vergleichst ob das Signal am D-Eingang '1' ist während das Signal am 
Q-Ausgang '0' ist.

Gruß

[Alexander F. (alexf91)]

Eliminiere alle Variablen, die benötigst du nicht.
Außerdem solltest du ieee.numeric_std.all verwenden und nicht die 
Synopsys Bibliotheken (du hast q als std_logic_vector deklariert).

p1: process(clk, reset)
begin
    if reset = '1' then
        q <= (others => '0');
        ce_o <= '0';
    elsif rising_edge(clk) then
        if ce_i = '1' then
            q <= q + 1;
            ce_o <= '1';
        end if;
    end if;
end process;

Im 2. Prozess kannst du das genau so machen.

Zur Flankenerkennung im 2. Prozess:
http://www.lothar-miller.de/s9y/categories/18-Flankenerkennung

Wieder die Frage: Hast du ein Buch oder sonstige Unterlagen?

[Forscher (Gast)]

Auch wenn in den Büchern asynchroner Resete gelehrt wird, sollte man ihn 
tunlichst vermeiden:

p1: process(clk)
begin
    if rising_edge(clk) then
      if reset = '1' then
        q <= (others => '0');
        ce_o <= '0';
       else
         if ce_i = '1' then
         --Überlaufbehandlung fehlt
            q    <= q + 1;
            ce_o <= '1';
         end if;
        end if;
     end if;
end process pl;

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

Forscher schrieb:
> Auch wenn in den Büchern asynchroner Resete gelehrt wird, sollte man ihn
> tunlichst vermeiden
Bei Lattice und Altera darf man durchaus einen asynchronen Reset 
beschreiben. Allerdings darf da dann nicht einfach ein asynchroner 
Resettaster drauf gelegt werden, sondern der Resettaster muss wie jedes 
andere asynchrone Signal auch einsynchronisiert werden. Denn sonst kann 
gleich der Start des Design schiefgehen, weil nicht alle Flipflops 
gleichzeitig aus dem Reset kommen. Und dann sind wir wieder da:
http://www.lothar-miller.de/s9y/archives/41-Einsynchronisieren-von-asynchronen-Signalen.html


Alex P. schrieb:
> Hier mal der gesamte Code.
Meine VHDL Beschreibungen fangen mit den verwendeten Packages an...

[Andi P. (jamaram90)]

Alexander F. schrieb:
> Wieder die Frage: Hast du ein Buch oder sonstige Unterlagen?

Ja ich besitze zahlreiche Vorlesungsunterlagen und auch das von dir 
schon angesprochene Buch. Ich werde mich da noch etwas weiter belesen.

Trotzdem vielen Dank für die Auskünfte und Antworten. Hilft mir schon 
sehr weiter.

Gruß

Alex

[Christoph Z. (christophz)]

Alex P. schrieb:
> Es sollte dann noch ein weiterer Prozess
> hinzukommen der auf ein zweites Signal achtet und im Prinzip da auch
> wieder nach Einstellung über Rx_buffer(0) dann ob auf steigende oder
> fallende Flanke getriggert werden soll.

Dann lohnt es sich jetzt schon, die Funktionalität für das eine Signal 
in einen separaten Funktionsblock zu packen (Sobald es läuft und 
getestet ist).

Dann kannst du danach in deinem Top Modul einfach für jedes zu 
überwachende Signal einfach einen Funktionsblock instantieren. Ohne den 
selben Code zweimal zu schreiben.

Ist auch eine gute Übung, das mal an etwas kleinerem auszuprobieren. Im 
erwähnten Buch kannst du das auch nachlesen unter "Struktureller VHDL 
Entwurf".