这是真正的FSM吗？

Question

我有一个关于FSM的概念问题，以及以下代码是否为真正的FSM。这是为了我自己的好奇心和对这个主题的理解。当我编写此代码时，我的印象是这是FSM，但现在我不确定。根据我完成的大量阅读，真正的FSM应仅由顺序状态过渡块组成，然后是一个或两个组合块来计算下一个状态和输出逻辑。

我当前的代码合成并在我的Basys3板上工作，所以我知道可能有一个论点“如果它不破产，请不要修复它”，但是现在我已经有一段时间了，因为我可能有不正确的理解关于如何在HDL中编写FSM。

我尝试使用上述格式至少尝试4或5种不同的方法来重写我的代码，但是我似乎在不推断闩锁的情况下无法获得它，这主要是由于使用计数器的使用，而PCKD_BCD需要记住这一事实。它的先前值。

有人可以向我解释为什么这种算法不适合真正的FSM，为什么它适合真正的FSM以及我的误解在哪里，或者如何将其重写为上述格式。

module double_dabble #
    (
    parameter NUM_BITS = 8
    )
    (
    input   wire                    i_clk,
    input   wire                    i_rst,
    input   wire    [NUM_BITS-1:0]  i_binary,
    output  wire    [15:0]          o_pckd_bcd
    );

localparam  s_IDLE      =   3'b000;
localparam  s_SHIFT     =   3'b001;
localparam  s_CHECK     =   3'b010;
localparam  s_ADD       =   3'b011;
localparam  s_DONE      =   3'b100;

reg     [2:0]           state;
reg     [NUM_BITS-1:0]  bin;
reg     [3:0]           count;
reg     [15:0]          pckd_bcd;
reg     [NUM_BITS-1:0]  input_reg;
reg     [15:0]          output_reg;

assign o_pckd_bcd   = output_reg;

always @(posedge i_clk) 
begin
    if(i_rst)
    begin
        state       <= s_IDLE;
        bin         <= 0;
        count       <= 0;
        pckd_bcd    <= 0;
        output_reg  <= 0;
        input_reg   <= 0;
    end

    else
    begin
        input_reg   <= i_binary;
        state       <= s_IDLE;

        // FSM
        case(state)
            s_IDLE :
            begin
                state       <= s_IDLE;
                bin         <= 0;
                count       <= 0;
                pckd_bcd    <= 0;
                if (input_reg!=i_binary)
                begin
                    bin     <= i_binary;
                    state   <= s_SHIFT;
                end
            end

            s_SHIFT :
            begin
                state       <= s_CHECK;
                bin         <= bin<<1;
                count       <= count+1;
                pckd_bcd    <= pckd_bcd<<1;
                pckd_bcd[0] <= bin[NUM_BITS-1];
            end

            s_CHECK :
            begin
                state   <=  s_ADD;
                if(count>=NUM_BITS)
                    state   <=  s_DONE;                                
            end

            s_ADD :
            begin
                state           <= s_SHIFT;
                pckd_bcd[15:12] <= add_three(pckd_bcd[15:12]);
                pckd_bcd[11:8]  <= add_three(pckd_bcd[11:8]);
                pckd_bcd[7:4]   <= add_three(pckd_bcd[7:4]);
                pckd_bcd[3:0]   <= add_three(pckd_bcd[3:0]);
            end

            s_DONE :
            begin
                state       <= s_IDLE;
                output_reg  <= pckd_bcd;
            end
        endcase
    end
end

function [3:0] add_three;
    input   [3:0] bcd;
    if (bcd > 4)
        add_three   = bcd +3;
    else
        add_three   = bcd;
endfunction

endmodule

Answer 1

通常，您的代码看起来像实现FSM。您有证据表明该设计正在按照董事会的需求工作。

您选择的编码样式（一个始终块）是有效的Verilog方法。另一种常见的FSM编码样式涉及两个始终块：一个顺序和一个组合。 here there FSM不得使用两个始终块中的块。

我在代码中确实注意到的一件事是，您正在同时对state信号进行多个非阻止分配。那是不寻常的。

例如，就在case语句之前，您有：

    state       <= s_IDLE;

然后，在indle case-item中，您具有相同的代码：

            state       <= s_IDLE;

我建议尝试通过添加来清理该码默认 <代码>案例语句。 默认在您的FSM中（如FSM）（如您的FSM）时，也是一个很好的编码练习。您仅定义了8个可能的状态中的5个（state是3位寄存器）。

多个非阻止分配的另一个示例是：

        s_CHECK :
        begin
            state   <=  s_ADD;
            if(count>=NUM_BITS)
                state   <=  s_DONE;                                
        end

将其编码更好地编码为：

        s_CHECK :
        begin
            state <= (count>=NUM_BITS) ? s_DONE : s_ADD;
        end

遵循建议的编码实践会产生更可预测的仿真和综合结果。