la construction d'un circuit anti-rebond?

[bara00]

Salut à tous

J'ai un laboratoire d'électronique où je dois construire et tester un circuit anti-rebond basculer en appuyant sur carte FPGA et en utilisant seulement une seule entrée.Je n'ai aucune idée de ce que de le faire pouvait-on m'aider s'il vous plaît???

J'ai eu à tester le circuit avec un bouton poussoir contre que j'ai déjà construit.

Je vous remercie

 

[Yego]

Ci-dessous vous trouverez ma conception de PWM avec quelques touches de contrôle qui sont sans rebond.
Vous pouvez facilement extraire la partie anti-rebond de la conception.
Ne me demandez pas comment cela fonctionne exactement.Cette conception est vieux de plusieurs années et je ne me souviens pas tous les détails, pas plus.
C'est peut-être quelque chose pour vous.Code:

IEEE bibliothèque;

IEEE.STD_LOGIC_1164.ALL utilisation;

IEEE.STD_LOGIC_ARITH.ALL utilisation;

IEEE.STD_LOGIC_UNSIGNED.ALL utilisation;

-------------------------------------------------- -----------------------------

debounce entité est

Port (db_clk: en std_logic; - un 10 ms debounce horloge

db_res: en std_logic; -

db_key_in: en std_logic; - premières (rebond) intrant clé, une clé est active LO

db_key_out: std_logic-out) - rebond des clés (pulsé ____ _______ ------------)

debounce fin;

-------------

debounce_arch architecture des anti-rebond est

signal K00: std_logic;

signal K01: std_logic;

signal K02: std_logic;

commencer

debounce_proc: Le processus (db_clk, db_res)

commencer

si db_res = '0 'alors

K00 <= '0 ';

K01 <= '0 ';

<K02 = '0 ';

rising_edge elsif (db_clk) puis

<= K02 K01;

K01 <= K00;

K00 <= pas db_key_in;

fin si;

processus de bout debounce_proc;

<Db_key_out = K00 et K01 et K02;

debounce_arch fin;

- ================================================ ===============================

IEEE bibliothèque;

IEEE.STD_LOGIC_1164.ALL utilisation;

IEEE.STD_LOGIC_ARITH.ALL utilisation;

IEEE.STD_LOGIC_UNSIGNED.ALL utilisation;-------------------------------------------------- ------------------------------

PWM entité est

Port (pwm_cntr: en std_logic_vector (5 downto 0);

pwm_clk: en std_logic; -.

pwm_res: en std_logic; -

- Pwm_db_change: en std_logic; -

pwm_change: en std_logic; -

- Pwm_db_dir: en std_logic; -

pwm_dir: en std_logic; -

pwm_cntr17: en std_logic; - horloge 10ms

pwm_out: std_logic-out) - sortie PWM

PWM fin;

--------

arch_pwm architecture PWM est

debounce COMPOSANT

PORT (

db_clk: std_logic IN;

db_res: std_logic IN;

db_key_in: std_logic IN;

db_key_out: std_logic OUT

);

COMPOSANT END;

-----------------

pwm_reg signal: std_logic_vector (5 downto 0);

signal pwm_db_change: std_logic;

pwm_db_dir signal: std_logic;

commencer

Inst_debounce1: debounce PORT MAP (

db_clk => pwm_cntr17,

db_res => pwm_res,

db_key_in => pwm_change,

db_key_out => pwm_db_change

);

Inst_debounce2: debounce PORT MAP (

db_clk => pwm_cntr17,

db_res => pwm_res,

db_key_in => pwm_dir,

db_key_out => pwm_db_dir

);pwm_proc: Le processus (pwm_db_change, pwm_res)

commencer

si pwm_res = '0 'alors

<Pwm_reg = "000000";

rising_edge elsif (pwm_db_change) puis

si pwm_db_dir = '1 'alors

si pwm_reg / = 63, puis

<= Pwm_reg pwm_reg 1;

d'autre

pwm_reg <= pwm_reg;

fin si;

pwm_reg elsif / = 0, alors

<= Pwm_reg pwm_reg - 1;

d'autre

pwm_reg <= pwm_reg;

fin si;

fin si;

processus de bout pwm_proc;

-----------------------

pwm_out_proc: Le processus (pwm_clk, pwm_res)

commencer

si pwm_res = '0 'alors

<Pwm_out = '0 ';

rising_edge elsif (pwm_clk) puis

if (pwm_cntr> pwm_reg) puis

<Pwm_out = '1 ';

d'autre

<Pwm_out = '0 ';

fin si;

fin si;

processus de bout pwm_out_proc;

arch_pwm fin;

- ================================================ ===============================

IEEE bibliothèque;

IEEE.STD_LOGIC_1164.ALL utilisation;

IEEE.STD_LOGIC_ARITH.ALL utilisation;

IEEE.STD_LOGIC_UNSIGNED.ALL utilisation;-------------------------------------------------- ------------------------------

multipwm entité est

Port (

horloge: dans std_logic; - Main PWM horloge, pour 16MHz PWM sera 250kHz.

reset: en std_logic; -

variation1: en std_logic; -

dir1: en std_logic; -

OUT1: std_logic à -

variation2: en std_logic; -

dos2: en std_logic; -

OUT2: std_logic à -

change3: en std_logic; -

dir3: en std_logic; -

OUT3: std_logic out); -

multipwm fin;

--------------

arch_multipwm architecture de multipwm est

PWM composante

port (

pwm_cntr: en std_logic_vector (5 downto 0);

pwm_clk: en std_logic; --.

pwm_res: en std_logic; -

pwm_change: en std_logic; -

pwm_dir: en std_logic; -

pwm_cntr17: en std_logic; -

pwm_out: std_logic out); -

composante fin;

signal contre: std_logic_vector (17 downto 0);

commencer - un compteur pour tous les PWMs

counter_proc: Le processus (horloge, reset)

commencer

Si la réinitialisation = '0 'alors

Counter <= "000000000000000000";

elsif rising_edge (horloge), puis

<Compteur = compteur 1;

fin si;

processus de bout counter_proc;

-------------------------------------------------- ------------------------------

Inst_pwm1: Plan du port PWM (

pwm_cntr => compteur (5 downto 0),

pwm_clk => 'horloge,

pwm_res => remise à zéro,

pwm_change => variation1,

pwm_dir => dir1,

pwm_cntr17 => compteur (17),

pwm_out => OUT1);

------------------------------------

Inst_pwm2: Plan du port PWM (

pwm_cntr => compteur (5 downto 0),

pwm_clk => 'horloge,

pwm_res => remise à zéro,

pwm_change => variation2,

pwm_dir => dos2,

pwm_cntr17 => compteur (17),

pwm_out => OUT2);

------------------------------------

Inst_pwm3: Plan du port PWM (

pwm_cntr => compteur (5 downto 0),

pwm_clk => 'horloge,

pwm_res => remise à zéro,

pwm_change => change3,

pwm_dir => dir3,

pwm_cntr17 => compteur (17),

pwm_out => OUT3);

------------------------------------

arch_multipwm fin;

 

[KiB]

Code:

IEEE bibliothèque;

ieee.std_logic_1164.all utilisation;-------------------------------------------------- -------------------------------------------------- ----------------debounce entité est

port (

premières: en std_logic;

Propreté: les std_logic;

CLK: en std_logic

);

debounce fin;RTL architecture des anti-rebond est

-------------------------------------------------- -------------------------------------------------- ----------------current_s signal, next_s: std_logic_vector (1 downto 0);

-------------------------------------------------- -------------------------------------------------- ----------------commencer- Logique combinatoire pour le prochain Etat

next_s <= "00" lorsque (brut = '1 ') else

«01» lorsque current_s = "00" d'autre

"10";- Logique combinatoire pour la sortie

Clean <= '0 'lorsque current_s = "10" else '1';- La logique séquentielle

processus (CLK)

commencer

if (clk'event et CLK = '1 ') puis

<= Current_s next_s;

fin si;

processus de bout;

RTL fin;

-------------------------------------------------- -------------------------------------------------- ----------------

 

[echo47]

Un commutateur doit debouncer dix ou vingt millisecondes de retard.Votre code ressemble à un détecteur de chute de pointe, pas un debouncer.

Voici un debouncer simple Verilog:
# 492226 http://www.edaboard.com/viewtopic.php?p=492226

 

[Black Jack]

A partir d'exemples HDL Altera.
Vous pouvez utiliser Xilinx XPORT pour traduire en langage VHDL ou Verilog

Code:%********************************

* *

Debouncer commutateur mécanique

* *

********************************%debounce SUBDESIGN

(

CLK: INPUT;

key_pressed: INPUT;

impulsions: SORTIE;

)VARIABLE

count_reg [7 .. 0]: DFF;

at_zero: node;BEGINPreset à 255% lorsqu'il rebondit clé ou n'est pas%

% Pressé. Decrement quand la touche est enfoncée.
%

count_reg] [. CLK CLK =;

count_reg] [. prn = key_pressed;

count_reg] [. d] = [count_reg. Q - (0,! at_zero);% Emit impulsion unique lorsque le compteur atteint 1.
%

h impulsion =] [count_reg. q == "01";% Ne laissez pas décrémenter compteur au-dessous de zéro.
%

h at_zero =] [count_reg. q == "00";END;