Edgedetector für 4 Eingänge

[Daniel C. (danny1)]

Hallo liebe mikrocontroller - Community,

Ich bin grad dabei einen Edgedetector in VHDL zu Bauen. Die Entity hat 4 
Eingänge und einen Ausgang. Das Ziel wäre jetzt bei jeder steigenden 
oder fallenden Flanke von jedem der 4 Eingänge den Ausgang einen 
Taktzyklus auf '1' zu setzen.
Mein Ansatz wäre das aktuell anstehende Signal mit dem vorhergehenden 
Signal von einem Registerausgang zu vergleichen.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity EdgeDetector is
      Port ( 
          -- Input ports
          clk       :  in  STD_ULOGIC;
          signal_in   :   in  STD_ULOGIC_VECTOR(3 downto 0);
          reset      :  in   STD_ULOGIC;
          
          -- Output ports
               output       :  out STD_ULOGIC
          );
          
end EdgeDetector;


architecture Behavioral of EdgeDetector is
     signal signal_a:STD_ULOGIC;
    signal signal_b:STD_ULOGIC;
    signal signal_c:STD_ULOGIC;
    signal signal_d:STD_ULOGIC;
    
    signal detectedEdge_a:STD_ULOGIC;
    signal detectedEdge_b:STD_ULOGIC;
    signal detectedEdge_c:STD_ULOGIC;
    signal detectedEdge_d:STD_ULOGIC;
    
    signal output1:STD_ULOGIC;
    signal output2:STD_ULOGIC;
    
begin
    process(clk, reset)
    begin
         if clk= '1' and clk'event then
               signal_a<=signal_in(0);
          signal_b<=signal_in(1);
          signal_c<=signal_in(2);
          signal_d<=signal_in(3);
          
         end if;
      
    end process;
   
   detectedEdge_a <= ((not signal_a) and signal_in(0)) or (signal_a and (not signal_in(0)));
   detectedEdge_b <= ((not signal_b) and signal_in(1)) or (signal_b and (not signal_in(1)));
   detectedEdge_c <= ((not signal_c) and signal_in(2)) or (signal_c and (not signal_in(2)));
   detectedEdge_d <= ((not signal_d) and signal_in(3)) or (signal_d and (not signal_in(3)));
   
   output1 <= detectedEdge_a or detectedEdge_b;
   output2 <= detectedEdge_c or detectedEdge_d;
   
   output <= output1 or output2;
     
end Behavioral;

Der Edgedetector spricht auf die fallende und steigende Flanke von 
Eingang 2 und 3 an also auf "signal_in(2) und signal_in(3)". Eingang 0 
und 1 also "signal_in(0) und signal_in(1)" ignoriert mein Detector 
leider.
Hat jemand eine Idee woran das liegen könnte?

PS: Der clk kommt von der PLL und hat einen Takt von 200MHz


LG,
Daniel

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

Daniel C. schrieb:
> Der Edgedetector spricht auf die fallende und steigende Flanke von
> Eingang 2 und 3 an also auf "signal_in(2) und signal_in(3)". Eingang 0
> und 1 also "signal_in(0) und signal_in(1)" ignoriert mein Detector
> leider.
Wie stellst du das fest? Funktioniert das Ganze in der Testbench?

> Mein Ansatz wäre das aktuell anstehende Signal mit dem vorhergehenden
> Signal von einem Registerausgang zu vergleichen.
 Woher kommen diese Flanken? Sind das asynchrone externe Signale?

BTW: kennst du die "xor" Funktion?

   detectedEdge_a <= signal_a xor signal_in(0);
   detectedEdge_b <= signal_b xor signal_in(1);
   :
   :

BTW2: Nimm wie der Rest der Welt std_logic statt der std_ulogic.

BTW3: warum nimmst du für die lokalen Signale nicht auch Vektoren? Dann 
wird deine Beschreibung wesentlich kompakter:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity EdgeDetector is
      Port ( 
          -- Input ports
          clk       :  in  STD_ULOGIC;
          signal_in   :   in  STD_ULOGIC_VECTOR(3 downto 0);
          reset      :  in   STD_ULOGIC;
          
          -- Output ports
          output       :  out STD_ULOGIC
          );
end EdgeDetector;

architecture Behavioral of EdgeDetector is
    signal signal_buf:STD_ULOGIC_VECTOR(3 downto 0);
    signal detectedEdge:STD_ULOGIC_VECTOR(3 downto 0);
begin
    signal_buf <= signal_in when rising_edge(clk); -- 4 Bits parallel eintakten 
    detectedEdge <= signal_buf xor signal_in;      -- 4 Bits parallel verrechnen
    output <= detectedEdge(0) or detectedEdge(1) or detectedEdge(2) or detectedEdge(3);   
end Behavioral;

[Klaus (Gast)]

So gehts noch einfacher:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity EdgeDetector is
      Port ( 
          -- Input ports
          clk       :  in  STD_ULOGIC;
          signal_in   :   in  STD_ULOGIC_VECTOR(3 downto 0);
          reset      :  in   STD_ULOGIC;
          
          -- Output ports
          output       :  out STD_ULOGIC
          );
end EdgeDetector;

architecture Behavioral of EdgeDetector is
    signal signal_buf:STD_ULOGIC_VECTOR(3 downto 0);
begin
    signal_buf <= signal_in when rising_edge(clk); -- 4 Bits parallel eintakten 
    output <= '1' when signal_in /= signal_buf else '0';
end Behavioral;

Immer noch vorausgesetzt, dass 'signal_in' synchron zu 'clk' ist 
(Wichtig!!!).

[Duke Scarring (Gast)]

Lothar M. schrieb:
> BTW2: Nimm wie der Rest der Welt std_logic statt der std_ulogic.
Ich verwende std_logic nur für Signale die an den FPGA-Pins liegen 
(in/out).
Im FPGA verhindert std_ulogic schon beim Compilieren das ein Signal 
mehrfach getrieben werden kann.

Duke

[Felix F. (wiesel8)]

Klaus schrieb:
> signal_buf <= signal_in when rising_edge(clk); -- 4 Bits parallel
> eintakten
>     output <= '1' when signal_in /= signal_buf else '0';

Kann das bitte jemand erklären?
Wie soll (sin \= sbuf) jemals wahr sein, wenn sin immer in sbuf 
geschrieben wird?

mfg

[Andreas (Gast)]

Felix F. schrieb:
> Kann das bitte jemand erklären?
> Wie soll (sin \= sbuf) jemals wahr sein, wenn sin immer in sbuf
> geschrieben wird?

Die erste Zeile macht den unterschied:

Felix F. schrieb:
>> signal_buf <= signal_in when rising_edge(clk);

Das wird ein FF und damit ein Takt Verzögerung. Du vergleichst also 
sin(T=n) mit sin(T=n+1) und das kann wahr werden.

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

Felix F. schrieb:
> Wie soll (sin \= sbuf) jemals wahr sein, wenn sin immer in sbuf
> geschrieben wird?
Dazwischen sitzt ein Flipflop (oder eher 4 Fliflops nebeneinander) ...