秒表¶

需求¶

让我们来设计一个简单的秒表：输出一个数字，每秒加一；同时有一个复位按钮，按一下就会恢复到零，然后继续每秒加一。

根据上面的需求，可以设计如下的输入输出信号：

输入：

1. reset: 1 表示复位按钮被按下，需要清零；0 表示不需要清零
2. clock: 频率为 1MHz 的时钟

输出：

1. timer: 4 位的数字，表示目前经过的秒数

波形¶

我们来分析上面的需求，首先秒表每秒输出都会加一，说明内部需要保存状态，所以我们需要用 时序逻辑 来实现这一部分功能。很自然地，我们可以用一个寄存器 timer_reg 来保存当前的秒数，然后把寄存器的输出连接到 timer 输出上，这样我们只要保证每 1s 中让 timer_reg 加一即可。

那么，接下来的第二个问题是，如何实现每 1s 让 timer_reg 加一呢？回忆一下，我们上面引入了一个频率为 1MHz 的时钟，也就是说，每 1us 都有一次时钟上升沿，每 1,000,000 次上升沿就是 1s 的时间。为了记忆现在经过了多少次上升沿，这又是一个状态，所以还是 时序逻辑，用一个寄存器 counter_reg 来保存当前经过了多少次上升沿。

具体实现就是每次上升沿 counter_reg 加一，当加到 1,000,000（准确来说是 0 到 999,999）的时候，可以知道经过了 1s 的时间，这时候给 timer_reg 加一，同时让 counter_reg 恢复到 0，重新计时，这样就实现了秒表的计时功能。

再来考虑需求里面的复位按钮：按下按钮让计时重新开始。这里有两种实现方法：

1. 按下按钮的时候，输出就变成了 0，这个符合输入一变，输出立即跟着变的特点，所以可以用 组合逻辑 实现：timer = reset ? 0 : timer_reg；同时在时钟上升沿的时候，如果发现 reset == 1，就设置 timer_reg = 0 和 counter_reg = 0，这样松开按钮的时候会从 0 开始计时。
2. 按下按钮的时候，在时钟上升沿进行检测，如果发现 reset == 1，就设置 timer_reg = 0 和 counter_reg = 0，从下一个周期开始，输出的 timer = timer_reg 就变成了 0。一个周期只有 1us 的时间，人无法感知。

考虑到 1MHz 太快，不方便画图，下面的波形图假设 1s 是 3 个时钟周期。

如果采用第一种方法，即 timer = reset ? 0 : timer_reg，得到的波形如下：

从这个图就可以看出组合逻辑与时序逻辑的区别：在 a 时刻，当 reset == 1 的时候，输出的 timer 立即就变成了 0，但是 timer_reg 和 counter_reg 的清零要等到 下一个时钟上升沿（b 时刻）才能生效。

如果采用第二种方法，即 timer = timer_reg，得到的波形如下：

请同学对照上面两个波形来理解一下组合逻辑和时序逻辑的区别。

电路¶

接下来考虑一下电路的实现，首先，上面的讨论得出，有两组寄存器 timer_reg 和 counter_reg，其中 timer_reg 是 4 位，和输出 timer 一致，不考虑溢出的问题；counter_reg 需要从 0 一路计数到 999,999，简单算一下 log2，可以得到需要 20 位。

确定好位数以后，来思考一下电路。首先是 counter_reg，它设计的逻辑就是，在每个 clock 上升沿进行更新，那么 counter_reg 的新值，也就是输入 D 有三种可能：

1. 当 reset == 1 的时候，设成 0
2. 否则，当 counter_reg == 999999 的时候，设成 0
3. 否则，设成 counter_reg + 1

上面 2 和 3 点提到的 counter_reg 实际上就是输出 Q，经过一系列的判断和逻辑，最后连接到了输入 D。

再来考虑一下 timer_reg，它的设计逻辑是，在每个 clock 的上升沿进行更新，它的新值，也就是输入 D 有三种可能：

1. 当 reset == 1 的时候，设成 0
2. 否则，当 counter_reg == 99999 的时候，设成 timer_reg + 1
3. 否则，保持不变

这些“可能”在电路上对应用组合逻辑实现的选择器，即根据条件的成立与否，选择不同的结果。

最后，我们把 timer_reg 的输出连接到 timer 输出即可。电路图如下：

这里采用的是上面提到的第二种方法，也就是 timer = timer_reg；如果要改成第一种方法的 timer = reset ? 0 : timer_reg，只需要在输出 timer 前面添加一段组合逻辑即可。

代码¶

最后再用 HDL 来实现如上的功能。

module timer (
  input wire clock,
  input wire reset,
  output wire [3:0] timer
);
  // TODO
endmodule

  logic [3:0] timer_reg;
  logic [19:0] counter_reg;

  // sequential
  always_ff @ (posedge clock) begin
    if (reset) begin
      timer_reg <= 4'b0;
      counter_reg <= 20'b0;
    end else begin
      if (counter_reg == 20'd999999) begin
        timer_reg <= timer_reg + 4'b1;
        counter_reg <= 20'b0;
      end else begin
        counter_reg <= counter_reg + 20'b1;
      end
    end
  end

  // combinatorial
  assign timer = timer_reg;

module timer (
  input wire clock,
  input wire reset,
  output wire [3:0] timer
);
  // TODO
endmodule

  reg [3:0] timer_reg;
  reg [19:0] counter_reg;

  // sequential
  always @ (posedge clock) begin
    if (reset) begin
      timer_reg <= 4'b0;
      counter_reg <= 20'b0;
    end else begin
      if (counter_reg == 20'd999999) begin
        timer_reg <= timer_reg + 4'b1;
        counter_reg <= 20'b0;
      end else begin
        counter_reg <= counter_reg + 20'b1;
      end
    end
  end

  // combinatorial
  assign timer = timer_reg;

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity timer is
    Port ( clock : in  STD_LOGIC;
           reset : in  STD_LOGIC;
           timer : out STD_LOGIC_VECTOR (3 downto 0));
end timer;

architecture behavior of timer is
signal timer_reg : STD_LOGIC_VECTOR (3 downto 0);
signal counter_reg : STD_LOGIC_VECTOR (19 downto 0);
begin
  -- sequential
  -- TODO

  -- combinatorial
  -- TODO
end behavior;

architecture behavior of timer is
signal timer_reg : STD_LOGIC_VECTOR (3 downto 0);
signal counter_reg : STD_LOGIC_VECTOR (19 downto 0);
begin
  -- sequential
  process(clock, reset)
  begin
    if clock='1' and clock'event then
      if reset='1' then
        timer_reg <= X"0";
        counter_reg <= X"00000";
      else
        if counter_reg=999_999 then
          timer_reg <= timer_reg + 1;
          counter_reg <= X"00000";
        else
          counter_reg <= counter_reg + 1;
        end if;
      end if;
    end if;
  end process;

  -- combinatorial
  timer <= timer_reg;
end behavior;

总结¶

经过这个例子，我们学会了如何确定哪些东西需要用一个寄存器来保存，并且如何用 if-then-else 的方式来方便地更新寄存器的值，而不用手动去写 ZZ = XX ? YY : ZZ 的代码，让综合器自动为我们做电路的转换。

扩展¶

同步复位与异步复位¶

如果你看过网上的一些代码，你可能会发现，有的代码对 reset 的处理并不同，例如：

always_ff @ (posedge clock, posedge reset) begin
  if (reset) begin
    // some simple reset logic
  end else begin
    // some logic
  end
end

always @ (posedge clock, posedge reset) begin
  if (reset) begin
    // some simple reset logic
  end else begin
    // some logic
  end
end

if reset='1' then
  -- some simple reset logic
elsif clock='1' and clock'event then
  -- some logic
end if;

这种写法和之前的区别是 reset 的处理不同，使用这种写法时，即使没有时钟上升沿，也可以复位，因此这种写法称为异步复位。而在上面实现的秒表例子采用的是同步复位，即在时钟上升沿的时候检查复位信号。两种写法都是可以的，在目前的学习阶段中，不需要区分二者的区别。如果你编写的硬件逻辑会运行在 Xilinx 的 FPGA 上，那么建议使用同步复位。

触发器类型¶

由于时钟和复位是十分常见的触发器的输入，因此通常使用的触发器在之前提到的输入 D，输入 C，输出 Q 的基础上，还添加了输入 R 用于复位，而根据同步复位和异步复位、复位的极性（高有效、低有效）的不同一共可以分为四类：

同步复位，高有效（SDFF_PP0 = Synchronous D Flip Flop, Positive/rising edge, Positive/active-high reset polarity, Reset to zero）：

同步复位，低有效（SDFF_PN0 = Synchronous D Flip Flop, Positive/rising edge, Negative/active-low reset polarity, Reset to zero）：

异步复位，高有效（DFF_PP0 = Asynchronous D Flip Flop, Positive/rising edge, Positive/active-high reset polarity, Reset to zero）：

异步复位，低有效（DFF_PN0 = Asynchronous D Flip Flop, Positive/rising edge, Negative/active-low reset polarity, Reset to zero）：

Xilinx Vivado 采用了另一种命名方式：

• FDCE: 异步复位到 0
• FDPE: 异步复位到 1
• FDRE: 同步复位到 0
• FDSE: 同步复位到 1

评论