Flankenerkennung

Das hier ist eine Flankenerkennung mit einer vorgeschalteten Synchronisationsstufe.
Diese Beschreibung lässt sich sehr effizient in ein FPGA implementieren und wird ohne große Anstrengungen bis zu 400MHz schnell ausgeführt. Durch die Verwendung eines lokalen Schieberegisters (Variable sr) bleiben alle relevanten Signale lokal.

library ieee;
use ieee.std_logic_1164.all;

entity edge_detect is
  port (async_sig : in std_logic;
        clk       : in std_logic;
        rise      : out std_logic;
        fall      : out std_logic);
end;

architecture RTL of edge_detect is
begin
  process
    variable sr : std_logic_vector (3 downto 0) := "0000";
  begin
    wait until rising_edge(clk);
    -- Flanken erkennen
    rise <= not sr(3) and sr(2);
    fall <= not sr(2) and sr(3);
    -- Eingang in Schieberegister einlesen
    sr := sr(2 downto 0) & async_sig;
  end process;
end architecture;

Daraus wird dann:...

Flankenerkennung mit Synchronisationsstufe

Hier eine Testbench:

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.numeric_std.ALL;
use ieee.math_real.all;

ENTITY tb_edgedetect_vhd IS
END tb_edgedetect_vhd;

ARCHITECTURE behavior OF tb_edgedetect_vhd IS 
   COMPONENT edge_detect
   PORT(
      async_sig : IN std_logic;
      clk : IN std_logic;          
      rise : OUT std_logic;
      fall : OUT std_logic
      );
   END COMPONENT;
   --Inputs
   SIGNAL async_sig :  std_logic := '0';
   SIGNAL clk :  std_logic := '0';
   --Outputs
   SIGNAL rise :  std_logic;
   SIGNAL fall :  std_logic;

BEGIN
   -- Instantiate the Unit Under Test (UUT)
   uut: edge_detect PORT MAP(
      async_sig => async_sig,
      clk => clk,
      rise => rise,
      fall => fall
      );

   clk <= not clk after 5 ns;

   -- Ein zufälliges asynchrones Signal erzeugen
   stim : process
     variable seed1, seed2 : POSITIVE;
     variable Rand : REAL;
     variable IRand : INTEGER;
   begin
     -- Zufallszahl ziwschen 0 und 1
     uniform(seed1, seed2, rand);
     -- daraus ein Integer zwischen 50 und 150
     irand := integer((rand*100.0 - 0.5) + 50.0 );
     -- und dann diese Zeit abwarten
     wait for irand* 1 ns;
     async_sig <= not async_sig;
   end process;

END;

Und das ist die resultierende Waveform:



Als kleiner Gimmick
Wenn statt

    rise <= not sr(3) and sr(2);
    fall <= not sr(2) and sr(3);

die folgende (genau funktionsgleiche) Beschreibung

    rise <= not sr(3) and     sr(2);
    fall <=     sr(3) and not sr(2);

verwendet wird, kommt das dabei raus:

Unnötige Inverter

Immer wieder gibt es in synchronen Designs das Problem, dass auch Eingangsimpulse auftreten können, die kürzer als die Abtastperiode sind. Wenn zum Beispiel die Taktfrequenz 50MHz (==> Zykluszeit 20ns) beträgt, der kürzeste Eingangspuls aber nur 19ns sein könnte, dann kann dieses Signal nicht zuverlässig eingetaktet und ausgewertet werden.

Ein Ausweg bietet hier, das Signal direkt am Pin in einem Merker-Flip-Flop asynchron zu speichern und dann einzusynchronisieren. Nach dem Eintakten wird das Merker-FF zurückgesetzt. Eine steigende Flanke wird so, unabhängig von ihrer Dauer, einen Impuls mit einer Dauer von 1 Taktzyklus ausgeben.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Spikedetector is
    Port ( clk      : in  STD_LOGIC;
           spikein  : in  STD_LOGIC;
           spikeout : out STD_LOGIC);
end Spikedetector;

architecture Behavioral of Spikedetector is
signal sr0    : std_logic := '0';
signal sr1    : std_logic := '0';
signal merkin : std_logic := '0';
begin
   -- Merker-FF
   process (sr1, spikein) begin
      if (sr1 = '1') then 
         merkin <= '0';
      elsif rising_edge(spikein) then 
         merkin <= '1'; 
      end if;
   end process;
   
   -- Asynchrones Merker-FF eintakten
   process begin
      wait until rising_edge(clk);
      if(sr1='1') then 
         sr0 <= '0'; 
         sr1 <= '0'; 
      else
         sr0 <= merkin; 
         sr1 <= sr0; 
      end if;
   end process;
   
   -- Flanken-Impulse ausgeben
   spikeout <= sr1;
end Behavioral;

Daraus wird das hier. Hier erkennt man, dass für das Merker-FF ein asynchrones FF mit Clear-Eingang verwendet wurde. Die Synchronisations-FFs sind synchron, da auch das Zurücksetzen taktsynchron geschieht.

Und so sieht das in der Simulation aus. Man erkennt, dass auch längere Pulse nur einen (1) Augangspuls ausgeben.

Manchmal hat man das Problem, dass ein Eingangsignal prellt, man aber nicht warten kann, bis das Prellen aufgehört hat. Eine Auswertung des Flankenwechsels soll schnellstmöglich, quasi beim ersten Prellen ausgelöst, nachfolgende Preller aber ignoriert werden. Als Bais dient dieses Signal:

Hier kann die Schieberegister-Entprellung wieder ganz einfach verwendet werden. Allein durch das Ändern des Vergleichswertes wird praktisch die Schaltempfindlichkeit der Erkennung angepasst.

if (sr="11111110")...   << sofort beim Wechsel 1->0
if (sr="11110000")...   << bei "sauberer Flanke" 1->0 (kritisch)
if (sr="10000000")...   << wenn Wechsel 1->0, und 0 liegt stabil

Kritisch ist die mittlere Abfrage, weil u.U. Flanken nicht erkannt werden, wenn vor und nach der Flanke keine stabilen Signale anliegen und das Signal  z.B. so aussieht:



Keine dieser unsauberen Flanken wird von dieser 2. Variante erkannt werden.

Hier der VHDL Code der Flankenerkennung:

:
signal sr     : std_logic_vector(7 downto 0);
signal flanke : std_logic;
signal pegel  : std_logic;
:
process (clk)
begin
   if rising_edge(clk) then
      -- Schieberegister
      sr <= sr(6 downto 0) & eingang;
      -- Flankenerkennung, 1 Sync-FF, dann sofort reagieren
      flanke <= '0';
      if (sr="11111110") then flanke <= '1' end if; -- fallend
      if (sr="00000001") then flanke <= '1' end if; -- steigend
      -- Entprellen
      if (sr="11111111") then pegel <= '1' end if; -- high
      if (sr="00000000") then pegel <= '0' end if; -- low
   end if;
end process;
: