Synchronize, debounce, detect

Three jobs, three circuits

All three circuits are a few flops in a row, which is why they get confused. Each removes one thing, and only that.

Synchronizing gives a signal from a pin or another clock a known timing to this clock. It removes timing uncertainty; R6.2 has the theory. Debouncing removes the pulses a mechanical contact makes as it settles, by waiting for a quiet interval. Edge detecting turns a level into a one-cycle pulse per rising edge, and it counts bounces as edges.

The order is always synchronize, then debounce, then detect. The debouncer and the detector are clocked logic, so they must only ever see a synchronized input.

The debouncer waits for quiet

A debouncer is a counter that restarts whenever its input changes back. While s2 equals level it holds at 0. When they differ it counts, and after STABLE cycles in a row it copies s2 into level. A bounce back to the old value restarts it.

assign level = s2;

localparam int STABLE = 4;               // cycles of quiet before a new level counts
logic [3:0] quiet;                       // cycles s2 has differed from level
always_ff @(posedge clk or negedge rst_n)
  if (!rst_n)                       begin level <= 1'b0; quiet <= '0; end
  else if (s2 == level)             quiet <= '0;          // no change, or a bounce back: restart
  else if (quiet == 4'(STABLE - 1)) begin level <= s2; quiet <= '0; end
  else                              quiet <= quiet + 1'b1;

STABLE sets both what is removed and what it costs. On this bench the longest bounce lasts two cycles. Measured: STABLE = 4 or 3 counts 1 press, STABLE = 2 counts 2, and STABLE = 1 counts 3. A real contact bounces for milliseconds. At 50 MHz, 10 ms is 500,000 cycles, so a real STABLE needs a 19-bit counter.

The lab

The lab ships the synchronizer and the edge detector with assign level = s2;. Run it: the last line reads presses=3. Replace that one line with the debouncer from the compare above and run again: presses=1. Then set STABLE to 2 and watch the count climb. Synthesize both versions: 27 cells with 11 flops, then 49 cells with 16 flops.

Try it

Each line is printed just after an edge. rise is 1 at edges 4, 7 and 10, once per pulse that came out of the synchronizer, and count takes each one at the following edge. One press, three counts.

Replace assign level = s2; with the debouncer from the compare block. level then rises once, at edge 14, and falls at edge 25, four edges after s2 settles each time; the last line reads presses=1.

`timescale 1ns/1ps
module tb;
  logic clk = 0;
  always #5 clk = ~clk;                   // rising edges at 5, 15, 25, ...
  logic rst_n = 1;                        // falls at 1 ns: a real edge, so an asynchronous reset acts before any clock
  int edge_n = -1;
  always @(posedge clk) edge_n = edge_n + 1;
  logic       btn = 0;
  logic [7:0] count;
  logic [8:0] bounce = 9'b111001011;      // btn for nine cycles, bit 0 first: 1 1 0 1 0 0 1 1 1
  presses dut (.clk(clk), .rst_n(rst_n), .btn(btn), .count(count));
  // Advance to the next rising edge, wait for the design to settle, then print one line.
  task automatic tick();
    @(posedge clk); #1;
    $display("e%0d btn=%b s2=%b level=%b rise=%b count=%0d", edge_n, btn, dut.s2, dut.level, dut.rise, count);
  endtask
  initial begin
    #1 rst_n = 0; tick(); tick(); rst_n = 1;   // asserted at 1 ns, edges 0 and 1 in reset, released 1 ns after edge 1
    tick();
    for (int i = 0; i < 9; i++) begin btn = bounce[i]; tick(); end   // the press, bouncing
    repeat (8) tick();                                               // held
    btn = 0;                                                         // released, cleanly
    repeat (8) tick();
    $display("presses=%0d", count);
    $finish(0);                             // quiet: no "$finish called" line
  end
endmodule

Check yourself

// presses: counts presses of a push button. btn comes from a pin: it is not
// timed to clk, and a mechanical contact bounces for a while when pressed.
module presses (
  input  logic       clk,
  input  logic       rst_n,
  input  logic       btn,
  output logic [7:0] count
);
  // 1. Synchronize: two flops in series give btn a known timing to clk.
  logic s1, s2;
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) begin s1 <= 1'b0; s2 <= 1'b0; end
    else begin s1 <= btn; s2 <= s1; end

  // 2. Detect the rising edge: a flop keeps last cycle's value.
  logic level, level_q;
  assign level = s2;
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) level_q <= 1'b0;
    else        level_q <= level;
  wire rise = level & ~level_q;

  // 3. Count one press per rising edge.
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n)    count <= '0;
    else if (rise) count <= count + 1'b1;
endmodule

module tb;
  logic clk = 0, rst_n = 1, btn = 0;
  logic [7:0] count;
  presses dut (.clk(clk), .rst_n(rst_n), .btn(btn), .count(count));
  task automatic cycles(input logic v, input int n);
    btn = v;
    repeat (n) begin #1 clk = 1; #1 clk = 0; end
  endtask
  initial begin
    #1 rst_n = 0;
    #1 rst_n = 1;
    repeat (2) begin                       // two presses
      cycles(1, 2); cycles(0, 1); cycles(1, 6);   // closes, bounces open, closes and stays
      cycles(0, 6);                              // released
    end
    $display("presses=%0d", count);
    $finish(0);
  end
endmodule

assign rise = d ^ d_q;

assign rise = d & ~d_q;

assign rise = (d_q == 1'b0) && (d == 1'b1);

assign rise = d && !d_q;