Question

当我们在verilog中编写FSM时，有两种方法来编写FSM，首先使用3个总是块（1用于下一个状态组合逻辑+ 1用于presene-＆gt;下一个状态时序逻辑+ 1用于输出逻辑）和第二种方式对于所有3个操作只使用一个总是块，但两种情况下的输出波是不同的......为什么会这样？

例如，我已经用两种方式编码了简单的fsm，并且我的输出被移动了20次单位

第一种方式：

//using one alwys block
module moore_20_1(x_in,y_out,clk,reset);
input wire clk,reset,x_in;
output reg y_out;

reg [1:0] state;

parameter start=2'b00,s0=2'b01,s1=2'b10,s2=2'b11;

always @ (posedge clk)//next state logic + ps->ns logic + output logic
begin
  if(reset==1'b1) begin
    state<=start;
    y_out<=0;
  end
else begin
  case(state)
    start: begin if(x_in) state<=s0;
          else state<=s0;
            y_out<=0;
          end
    s0: begin if(x_in) state<=s1;
      else state<=s0;
      y_out<=0;
    end
    s1: begin if(x_in) state<=s2;
      else state<=s1 ;         
      y_out<=0;
    end
    s2: begin if(x_in) state<=s0;
      else state<=s2;
      y_out<=1;
    end
    endcase


end
end
endmodule

第二种方式

    //moore machine using 3 always block(ps->ns+output logic+next-sate logic)
module moore_5_20_2(x_in,y_out,clk,reset);
input wire clk,reset,x_in;
output reg y_out;

reg [1:0] state;
reg [1:0] next_state; 

parameter start=2'b00,s0=2'b01,s1=2'b10,s2=2'b11;

//ps->ns logic
always@ (posedge(clk))
if(reset==1'b1) 
  next_state<= #1 start;
else
  next_state<= #1 state;


//next-stae logic  
always @(next_state,x_in)
case(next_state)
  start: begin if(x_in) state<=s0;
          else state=s0;
          end
    s0: begin if(x_in) state<=s1;
      else state=s0;
    end
    s1: begin if(x_in) state<=s2;
      else state=s1 ;         
    end
    s2: begin if(x_in) state<=s0;
      else state=s2;
    end
    endcase

//OUTPUT LOGIc

always@(next_state)
if (reset==1'b1) y_out<= 0;
else begin 
    case(next_state)
      start:y_out<= 0;
      s0: y_out<=   0;
      s1: y_out<=0;
      s2: y_out<=#1 1;

    endcase
  end
endmodule

为什么输出移动了20个单位..？

Answer 1

我将对您如何测试这两个进行一些假设，即您在测试平台中有类似的东西：

initial begin 
  clk = 0; 
  forever #10 clk = ~clk; 
end

我还假设第二种方式是在第一种方式之前的20（或19？）时间单位，基于我认为出错的方式。

基本上，第一种方法是在寄存器中缓冲输出y_out，而第二种方式是在组合中设置y_out。

由于这是一台Moore机器（这两种实现都是这样），因此输出仅取决于当前状态。在第一种方式中，在时钟边缘，y_out被设置为基于＆＃34;当前＆＃34;的值。状态（即，状态是时钟边缘之前的那一刻）。虽然状态也可能在时钟边沿发生变化，但直到为此时钟周期确定了y_out的下一个值之后才会发生这种情况。这意味着在一个时钟周期内，y_out将根据前一周期的状态进行设置，并保持这种状态直到下一个时钟周期。

在第二种方式中，y_out是组合设置而不是时钟边缘。在这种情况下，下一个状态逻辑将确定state，当时钟边缘出现时，next_state将变为state（由于某种原因，在1个时间单位之后......）。因此，现在确定输出y_out的组合块将被唤醒并将y_out设置为该状态的任何值。因此，y_out将采用当前状态的输出，即该时钟周期的状态，而不是第一种方式的前一个时钟周期的状态。

例如，假设我们处于状态s1并且x_in被声明。因此，第二种方式state已准备好s2以准备过渡。时钟优势来了。

在第一种方式中，始终阻止唤醒。 reset并未在案例陈述中断言。我们在s1和x_in被置位，因此state将变为s2，y_out将设置为0.完成直到下一个时钟边缘。因此，看起来我们在s2并且y_out为0，直到下一个时钟边缘，此时y_out将变为1。

在第二种方式中，状态寄存器总是阻塞唤醒，next_state在1个单位后变为s2。 next_state变为s2后，y_out的输出逻辑始终会被唤醒，现在next_state为s2，因此y_out现在将变为1 （或在1次单位后再次？）。所以看起来我们在s2并且y_out是1（大致），这是前面约20个单位。

注意：此处涉及的大部分混淆（部分如Tim所提到的）并不是特别好的风格。我更喜欢第二种方式，但是你实现它的方式有点不理想。下面是一个建议的重写以供将来参考（虽然我确实采取了一些简化自由）：

module nice_moore_machine(
  input wire clock, reset, x_in,
  output reg y_out);

reg [1:0] state, next_state;

parameter start = 2'b00, s0 = 2'b01, s1 = 2'b10, s2 = 2'b11;

/* State register (synchronous reset) */
always @(posedge clk) begin
  if (reset) begin
    state <= start;
  end
  else begin
    state <= next_state;
  end
end

/* Next state logic */
always @(*) begin
  case (state)
    start: begin
      next_state = s0;
    end
    s0: begin
      next_state = (x_in) ? s1 : s0;
    end
    s1: begin
      next_state = (x_in) ? s2 : s1;
    end
    s2: begin
      next_state = (x_in) ? s0 : s2;
    end
  endcase
end

/* Output logic */
always @(*) begin
  y_out = (state == s2); /* Note that y_out could be a net and use an assign in this case */
end

endmodule

希望这有助于您更好地理解！

FSM（摩尔机器）verilog

1 个答案: