Lothar Miller - Entprellung

Tastenentprellung

nospam@example.com (Lothar Miller) — Tue, 07 Oct 2008 07:30:48 +0200

Wird eine Taste oder ein mechanischer Schalter einfach so an einen Pin angeschlossen und damit ein Zähler hochgezählt oder Zustände weitergeschaltet, kommt oft eine unangenehme Überraschung: der Zähler zählt viel zu viele Impulse, die State-Machine springt wild hin- und her.

Mit einer Beschreibung wie dieser wird das unausweichlich passieren:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.numeric_std.ALL;

entity Bouncing is
    Port ( clk    : in   STD_LOGIC;
           keyin  : in   STD_LOGIC;
           counter: out  STD_LOGIC_VECTOR(7 downto 0));
end Bouncing;

architecture Behavioral of Bouncing is
signal cnt : integer range 0 to 255 := 0;
keyinold   : std_logic;
begin
   process begin
      wait until rising_edge(clk);
      -- Flankenerkennung steigende Flanke
      if (keyin='1' and keyinold='0') 
         then cnt <= cnt+1;
      end if;
      keyinold <= keyin;
   end process;
   counter <= std_locig_vector(to_unsigned(cnt,8));
end Behavioral;

Mechanische Kontakte können ziemlich lange prellen. Ein FPGA mit einer Taktfrequenz von z.B. 50MHz sieht dann viele einzelne Ein- und Aus-Zustände und reagiert dementsprechend.

Hier jetzt 3 Möglichkeiten, diese prellenden Kontakte sicher auszuwerten:
Mit einem Schieberegister, wie der MAX6816 und gleich 8 Taster auf einmal wie der MAX6818.

Tastenentprellung mit Schieberegister

nospam@example.com (Lothar Miller) — Tue, 07 Oct 2008 06:45:00 +0200

Der Witz bei dieser Entprelllogik ist ein Schieberegister, in das der Eingangspegel eingetaktet wird. Auf diese Art erschlägt man gleich mehrere Fliegen mit einer Klappe:

1. Einsynchronisieren eines asynchronen Eingangs
(das asynchrone Verhalten haben mechanische Konakte so an sich)

2. Entprellung über die Schieberegisterbreite

3. einfache Flankenauswertung

Hier der Beispielcode:

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

entity debounce is
    Port ( clk      : in   STD_LOGIC;
           input    : in   STD_LOGIC;
           output   : out  STD_LOGIC;
           riseedge : out  STD_LOGIC;
           falledge : out  STD_LOGIC);
end debounce;

architecture Behavioral of debounce is
signal prescaler : integer range 0 to 10000;
signal inputsr   : std_logic_vector(3 downto 0);
begin
   process begin
   wait until rising_edge(clk);
   if (prescaler=0) then
      prescaler <= 10000;
      -- Pegel zuweisen
      if (inputsr = "0000") then output<='0'; end if;
      if (inputsr = "1111") then output<='1'; end if;
      -- steigende Flanke
      riseedge <= '0';
      if (inputsr = "0111") then riseedge<='1'; end if;
      -- fallende Flanke
      falledge <= '0';
      if (inputsr = "1000") then falledge<='1'; end if;
      -- von rechts Eintakten
      inputsr <= inputsr(2 downto 0) & input;
   else
      prescaler <= prescaler-1;
   end if;
   end process;
end Behavioral;

Tasterentprellung wie MAX6816

nospam@example.com (Lothar Miller) — Tue, 07 Oct 2008 06:17:00 +0200

Mit dem Maxim-Dallas Baustein MAX6816 gibt es eine Harwarelösung zur Entprellung einer Taste. Eigentlich ein schöner kleiner Baustein, ist es trotzdem sinnvoll, diese Funktionalität ins FPGA zu übernehmen.

Hier ein Bild aus dem Datenblatt

Der folgende VHDL-Code bildet das Verhalten des Bausteins nach:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.numeric_std.ALL;

entity Debounce is
    Port ( clk    : in  STD_LOGIC;
           keyin  : in  STD_LOGIC;
           keyout : out  STD_LOGIC);
end Debounce;

architecture Behavioral of Debounce is
signal keydeb : std_logic := '0';
signal debcnt : integer range 0 to 63 := 0;
begin
   process begin
      wait until rising_edge(clk);
      -- XOR
      if (keyin=keydeb) then debcnt <= 0;
      else                   debcnt <= debcnt+1;
      end if;
      -- Latch
      if (debcnt=63) then keydeb <= keyin; 
      end if;
   end process;
   keyout <= keydeb;

end Behavioral;

Tasterentprellung wie MAX6818 / Worbreite generisch

nospam@example.com (Lothar Miller) — Tue, 07 Oct 2008 06:15:00 +0200

Und jetzt nochmal das ganze für eine konfigurierbare Anzahl von Eingängen. Am INT Ausgang wird ein Interruptsignal beim entprellten Wechsel eines der Eingänge ausgegeben.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.numeric_std.ALL;

entity Debounce is
    Generic ( width  : natural := 8;
              delay  : natural := 63);
    Port ( clk       : in   STD_LOGIC;
           keyin     : in   STD_LOGIC_VECTOR(width-1 downto 0);
           keyout    : out  STD_LOGIC_VECTOR(width-1 downto 0);
           int       : out  STD_LOGIC);
end Debounce;

architecture Behavioral of Debounce is
signal keydeb : STD_LOGIC_VECTOR(width-1 downto 0) := (others=>'0');
signal debcnt : integer range 0 to delay := 0;
begin
   process begin
      wait until rising_edge(clk);
      if (keyin=keydeb) then debcnt <= 0;
      else                   debcnt <= debcnt+1;
      end if;
      int <= '0';
      if (debcnt=delay) then 
         keydeb <= keyin; 
         int    <= '1';
      end if;
   end process;
   keyout <= keydeb;

end Behavioral;