运维做开发

这个屌丝很懒，什么也没留下！

热门标签

Verilog状态机_verilog 状态机

作者：运维做开发 | 2024-08-01 20:14:56

踩

verilog 状态机

状态机定义

有限状态机 Finite State Machine，表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。有限状态机是指输出取决于过去输入部分和当前输入部分的时序逻辑电路。一般来说，除了输入部分和输出部分外，有限状态机还含有一组具有“记忆”功能的寄存器，这些寄存器的功能是记忆有限状态机的内部状态，它们常被称为状态寄存器。在有限状态机中，状态寄存器的的下一个状态不仅与输入信号有关，而且还与该寄存器的当前状态有关，因此有限状态机又可以认为是组合逻辑和寄存器逻辑的一种组合。其中，寄存器逻辑的功能是存储有限状态机的内部状态；而组合逻辑有可以分为次态逻辑和输出逻辑两部分，次态逻辑的功能是确定有限状态机的下一个状态，输出逻辑的功能是确定有限状态机的输出。有限状态机是由寄存器和组合逻辑构成的硬件时序电路。有限状态机的状态只可能在同一时钟变沿情况下才能从一个状态跳转到另一个状态。

状态转移

状态转移表示当发生指定事件且满足指定条件时，第 1 个状态中的对象将执行某些操作并进入第 2 个状态，即“触发”了转移。将触发转移之前的状态定义为“源状态”（当前状态，current_state），而触发转移之后的状态定义为“目标状态”（下一状态，next_state）。状态的转换由时钟信号驱动。

（1）Moore 型状态机

Moore 型状态机输出为当前状态的函数，由于状态的变化与时钟同步，因此输出的变

化也与时钟同步，属于同步输出电路模型。我们可以用图 2 所示的状态转换图来描述

Moore 型状态机，其电路结构框图如图 3 所示。

（2） Mealy 型状态机

Mealy 型状态机的输出为当前状态和所有输入信号的函数，由于输入信号与时钟信号无关，因此其输出在输入变化后将立即发生变化，不依赖时钟，因此 Mealy 型状态机属于异步输出电路模型。我们可以用图 4 所示的状态转换图来描述 Mealy 型状态机，其电路结构框图如图 5 所示。

Moore 型有限状态机其输出信号仅与当前状态有关，即可以把 Moore 型有限状态的输出看成是当前状态的函数。Mealy 型有限状态机其输出信号不仅与当前状态有关，而且还与所有的输入信号有关，即可以把 Mealy 型有限状态机的输出看成是当前状态和所有输入信号的函数。

同步状态机和异步状态机

异步状态机是没有确定时钟的状态机，其状态转移不由唯一的时钟边沿触发。因此，应尽量不要使用综合工具来设计异步状态机。目前大多数综合工具对异步状态机进行逻辑优化时会胡乱的简化逻辑，是综合后的异步状态机不能正常工作。如果一定要设计异步状态机，建议采用电路图输入的方法，而不要用 Verilog 输入的方法。为了能综合出有效的电路，用 Verilog 描述的状态机应明确地由唯一时钟触发，称之为同步状态机，它是设计复杂时序逻辑电路最有效、最常用的方法之一。

单进程、双进程和多进程状态机

可以有 3 种不同的方式实现对状态机的描述。

1 3 个模块用一个进程实现，也就是说 3 个模块均在一个 always 块内，这种状态机描

述称为单进程有限状态机，它既描述状态转移，又描述状态的寄存和输出。

2 3 个模块对应着 2 个 always 块，“状态译码”“输出译码”分配在一个进程中，“状态

寄存器”用另一个进程描述。这种状态机描述称为双进程有限状态机。

③ 每一个模块分别用一个进程实现，也就是说 3 个模块对应着 3 个 always 块，这种状

态机描述称为三进程有限状态机。

1.一段式状态机：一段式状态机只选择一个状态标志位，这个状态标志位会在输入的决定下选择跳转到下一个状态还是维持原有状态，在每一个状态下检测状态标志位及输入来决定其状态的跳转及输出。其输出和状态的切换在一个 always 循环块中执行。

2.二段式状态机：二段式状态机将状态分为当前状态和此状态，其系统会自动将次状态更新到当前状态，其输入更新在次状态上，其决定系统的状态切换和输出。其输出和状态的切换在两个 always 循环块中执行，第一个 always 块决定系统状态标志的自动跳转，第二个 always 块决定系统根据不同状态下的输入进行状态的跳转及输出。

3.三段式状态机：二段式状态机将状态分为当前状态和此状态，其系统会自动将次状态更新到当前状态，系统的输入更新在次状态上，其决定系统的状态切换，系统会根据其当前状态决定输出的值。其输出和状态更新和状态切换在三个 always 块中，第一个always 块决定系统状态标志的自动跳转，第二个 always 块决定系统根据不同状态下的输入进行状态的切换，第三个 always 块根据系统的当前状态决定输出的值。

关于三段式状态机的总结：

①确定输入输出信号，及其类型（是 wire 还是 reg）；

②声明内部信号，一般需要定义 current_state 和 next_state；

③用 3 个 always 语句描述状态机;第一个用来次态和现态的转换，第二个 always 用于现态在输入情况下转换为次态的组合逻辑；第三个语句用于现态到输出的组合逻辑输出。

有限状态机设计流程

一个有限状态机的结构总是可以被分为以下几项。

（1）状态译码：根据外部输入的控制信号及当前状态（current_state）确定下一状态（next_state）的取值。采用组合逻辑判断状态转移条件，描述状态转移规律。

（2）状态寄存器：采用同步时序描述状态转移。负责状态机运行和在时钟驱动下状态转换的过程：当时钟信号的有效边沿到达时，主控时序过程将代表次态的信号next_state中的内容送入现态的信号current_state中，而信号next_state中的内容完全由其他过程根据实际情况来决定。

（3）输出译码：描述每个状态的输出。

通过单always模块方式、双always模块方式和三always模块方式实现单进程、双进程和三进程状态机。

单always模块方式

将整个状态机的设计写到一个always模块中，既描述状态输入和输出，又描述状态转移，其特点是利用寄存器完成输出从而不易产生毛刺，易于进行逻辑综合，缺点是代码可读性差，不利于修改、完善及维护，且状态向量和输出向量均由寄存器实现，会消耗较大的芯片资源，无法实现Mealy状态机。

双always模块方式

双always模块方式有2个always块，其中一个always模块采用同步时序描述状态转移，另一个always模块采用组合逻辑判断状态转移条件，描述状态转移规律及输出。其优点是面积和时序的优势，但由于输出是当前状态的组合函数，又存在下述问题：输出会产生毛刺；状态机的输出向量必须由状态向量译码，增加了状态向量到输出的延迟；组合逻辑占用了一定的传输时间，增加了驱动下一模块的输入延迟，不利于系统的综合优化

三always模块方式

将“状态译码”“状态寄存器”“输出译码”分别写出一个always模块，即称为“三always模块方式”。

上述的3个always模块中，一个always模块采用同步时序描述状态转移；一个always模块采用组合逻辑判断转移条件，描述转移规律；另一个always模块描述状态的输出。其优点是程序可读性强，占用芯片面积适中，无毛刺，有利于综合。

实际问题要求与分析

自动售货机是有限状态机的经典实例，现在就一个可乐售货机来进行分析。

要求：售货机里有价值4元的可乐，支持1元和2元硬币。请设计一个状态机，检测投入的硬币，当累计投入币值大于等于可乐价格时，售货机自动找零并弹出1瓶可乐。硬币和商品都是一个一个的进出，不会出现一次性投很多个硬币弹出很多瓶可乐的情况。

三段式状态机：

三段式状态机，第一段用时序逻辑描述state_c（现态）；第二段用组合逻辑描述状态转移，也即确定state_n（次态）；第三段用时序逻辑描述输出，第三段可以是多个always块。


module FSM_3
//---------------------<端口声明>---------------------------------------
(input                   clk      ,
input                   rst_n    ,
input      [1:0]        in       ,
output reg [1:0]        out      ,
output reg              out_vld
);
//---------------------<信号定义>---------------------------------------
reg  [3:0]              state_c   ;
reg  [3:0]              state_n   ;
//---------------------<状态机参数>-------------------------------------
localparam S0           = 4'b0001  ;
localparam S1           = 4'b0010  ;
localparam S2           = 4'b0100  ;
localparam S3           = 4'b1000  ;
 
//----------------------------------------------------------------------
//--   状态机第1段
//----------------------------------------------------------------------
always @(posedge clk or negedge rst_n)begin
    if(!rst_n)
        state_c <= S0;
    else
        state_c <= state_n;
end
 
//----------------------------------------------------------------------
//--   状态机第2段
//----------------------------------------------------------------------
always @(*)begin
    case(state_c)
        S0: begin
            if(in==1)
                state_n = S1;
            else if(in==2)
                state_n = S2;
            else
                state_n = state_c;
        end
        S1: begin
            if(in==1)
                state_n = S2;
            else if(in==2)
                state_n = S3;
else
                state_n = state_c;
        end
        S2: begin
            if(in==1)
                state_n = S3;
            else if(in==2)
                state_n = S0;
            else
                state_n = state_c;
        end
        S3: begin
            if(in==1 || in==2)      // in != 0也行
                state_n = S0;
            else
                state_n = state_c;
        end
        default:state_n = S0;
    endcase
end
 
//----------------------------------------------------------------------
//--   状态机第3段
//----------------------------------------------------------------------
//找零钱
always @(posedge clk or negedge rst_n)begin
    if(!rst_n)
        out <= 0;
    else if(state_c==S3 && in==2)
        out <= 1;
    else
        out <= 0;
end
 
//输出可乐
always @(posedge clk or negedge rst_n)begin
    if(rst_n==1'b0)
        out_vld <= 0;
    else if((state_c==S2 && in==2) || (state_c==S3 && in!=0))
        out_vld <= 1;
    else
        out_vld <= 0;
end
endmodule

编写测试文件testbech：


`timescale 1ns/1ps  //时间精度
`define    Clock 20 //时钟周期
 
module FSM_3_tb;
//--------------------< 端口 >------------------------------------------
reg                     clk                 ;
reg                     rst_n               ;
reg  [1:0]              in                  ;
wire [1:0]              out                 ;
wire                    out_vld             ;
 
//----------------------------------------------------------------------
//--   模块例化
//----------------------------------------------------------------------
FSM_3 u_FSM_3
(
    .clk                (clk                ),
    .rst_n              (rst_n              ),
    .in                 (in                 ),
    .out                (out                ),
    .out_vld            (out_vld            )
);
 
//----------------------------------------------------------------------
//--   状态机名称查看器
//----------------------------------------------------------------------
localparam S0           = 4'b0001           ;
localparam S1           = 4'b0010           ;
localparam S2           = 4'b0100           ;
localparam S3           = 4'b1000           ;
//2字符16位
reg [15:0]              state_name          ;
 
always@(*)begin
    case(u_FSM_3.state_c)
        S0:     state_name = "S0";
        S1:     state_name = "S1";
        S2:     state_name = "S2";
        S3:     state_name = "S3";
        default:state_name = "S0";
    endcase
end
 
//----------------------------------------------------------------------
//--   时钟信号和复位信号
//----------------------------------------------------------------------
initial begin
    clk = 1;
    forever
    #(`Clock/2) clk = ~clk;
end
 
initial begin
    rst_n = 0; #(`Clock*20+1);
    rst_n = 1;
end
 
//----------------------------------------------------------------------
//--   设计输入信号
//----------------------------------------------------------------------
initial begin
    #1;
    in = 0;
    #(`Clock*20+1); //初始化完成
//情况1--------------------------
    in = 1;         //1块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*1);
    in = 1;         //1块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*1);
    in = 1;         //1块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*1);
    in = 1;         //1块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*10);
//情况2--------------------------
    in = 1;         //1块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*1);
    in = 1;         //1块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*1);
    in = 1;         //1块钱
    #(`Clock*1);
 in = 0;
    #(`Clock*1);
    in = 2;         //2块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*10);
//情况3--------------------------
    in = 1;         //1块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*1);
    in = 1;         //1块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*1);
    in = 2;         //2块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*10);
//情况4--------------------------
    in = 1;         //1块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*1);
    in = 2;         //2块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*1);
    in = 2;         //2块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*10);
//情况5--------------------------
    in = 2;         //2块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*1);
    in = 2;         //2块钱
    #(`Clock*1);
    in = 0;
    #(`Clock*10);
    $stop;
end
endmodule

三段式状态机RTL视图如下:

三三段式状态机引脚框图如下：

小结

三段式状态机和二段式状态机是非常类似的，只不过是多加了一个 always 块来实现FSM状态的一个寄存，使FSM做到了同步寄存器输出，消除了组合逻辑输出的不稳定与毛刺的隐患，而且更利于时序路径分组，一般来说在FPGA等可编程逻辑器件上的综合与布局布线效果更佳。一段式状态机不利于维护,尽量不使用。一般而言,推荐的FSM 描述方法是后两种。这是因为：FSM和其他设计一样，最好使用同步时序方式设计，以提高设计的稳定性，消除毛刺。状态机实现后，一般来说，状态转移部分是同步时序电路而状态的转移条件的判断是组合逻辑。第二种描述方法同第一种描述方法相比，将同步时序和组合逻辑分别放到不同的always模块中实现，这样做的好处不仅仅是便于阅读、理解、维护，更重要的是利于综合器优化代码，利于用户添加合适的时序约束条件，利于布局布线器实现设计。在第二种方式的描述中，描述当前状态的输出用组合逻辑实现，组合逻辑很容易产生毛刺，而且不利于约束，不利于综合器和布局布线器实现高性能的设计。第三种描述方式与第二种相比，关键在于根据状态转移规律，在上一状态根据输入条件判断出当前状态的输出，从而在不插入额外时钟节拍的前提下，实现了寄存器输出。

Moore型：状态机的状态变化仅和当前状态有关；时序逻辑电路的输出只取决于当前状态。设计高速电路时常用此类状态机，把状态变化直接用作输出。

Mealy型：状态机的状态变化不仅与当前的状态有关，还取决于当前的输入条件（时序逻辑的输出不但取决于状态还取决于输入。平常使用较多的是此类状态机。

“其实这几种状态机之间，只要做一些改变，便可以从一种形式转变为另一种形式。把状态机精确的分为这类或那类，其实并不重要，重要的是设计者如何把握输出的结构能满足设计的整体目标，包括定时的准确性和灵活性。”

状态机设计判断标准：

第一，状态机要安全，是指FSM不会进入死循环，特别是不会进入非预知的状态，而且由于某些扰动进入非设计状态，也能很快的恢复到正常的状态循环中来。(三段式状态机可以尽可能的避免状态输出的不稳定和毛刺的问题)

第二，状态机的设计要满足设计的面积和速度的要求。

第三，状态机的设计要清晰易懂、易维护。

注意,用always模块写组合逻辑时，采用阻塞赋值，而在always块中建立时序电路时，用非阻塞赋值。这样才能保证有限状态机综合前和综合后仿真的一致

//https://blog.csdn.net/weixin_42455055/article/details/119118162

状态机基本概念：

状态机由状态寄存器和组合逻辑电路构成，能够根据控制信号按照预先设定的状态进行状态转移，是协调相关信号动作、完成特定操作的控制中心。

如何写一个高质量的状态机：

1、安全性：综合实现无毛刺异常扰动，状态机要完备，既不会进入死循环，哪怕偶然跑偏也能恢复到正常状态（三度段式+状态完备）；

2、速度：速度要快，满足设计频率的要求；

3、面积：面积要小，满足设计的面积要求；

4、易懂易维护性：FSM设计要清晰易懂，易维护（采用三段式）。

2、3需要有较强的电路时序分析功底才能比较好的优化，要非常熟悉verilog综合（DC）出来的电路情况，要有一定的静态时序分析（STA）和优化的能力，初学者能做好1、4就很不错了。

FSM实现实现11010110序列输出


module FSM_gener(
    input                    clk,
    input                    rst_n,
    
    output reg                data_current
);
    //变量分配定义
    reg    [3:0] state_current;
    reg    [3:0] state_next;
    reg       data_next;
 
 
    localparam                   //使用格雷码，减少数据翻转，减小误码率和功耗
        IDEL  = 4'b0000,
        ONE   = 4'b0001,
        TWO   = 4'b0011,
        THREE = 4'b0010,
        FOUR  = 4'b0110,
        FIVE  = 4'b0111,
        SIX   = 4'b0101,
        SEVEN = 4'b0100,
        EIGHT  = 4'b1100;
 
 
    //第一段状态机,时序逻辑状态更新
    always@( posedge clk or negedge rst_n ) begin
        if( !rst_n )
            state_current <= IDEL;
        else
            state_current <= state_next;
    end
    
    //第二段状态机，组合逻辑状态判断跳转
    always@( * ) begin
        case( state_current )
            IDEL:begin
                    state_next <= ONE;    
                    data_next <= 1'b0;
                 end
            ONE:begin
                    state_next <= TWO;
                    data_next <= 1'b1;
                end
            TWO: begin
                    state_next <= THREE;
                    data_next <= 1'b1;
                 end
            THREE:begin
                    state_next <= FOUR;
                    data_next <= 1'b0;
                  end
            FOUR:begin
                    state_next <= FIVE;
                    data_next <= 1'b1;
                 end
            FIVE:begin
                    state_next <= SIX;
                    data_next <= 1'b0;
                 end
            SIX: begin
                    state_next <= SEVEN;
                    data_next <= 1'b1;
                 end
            SEVEN:begin
                    state_next <= EIGHT;
                    data_next <= 1'b1;
                  end
            EIGHT:begin
                    state_next <= IDEL;
                    data_next <= 1'b0;
                  end
            default:begin
                        state_next <= IDEL;
                        data_next <= 1'b0;
                    end
        endcase
    end
    
    //第三段状态机，时序逻辑数据输出
    always@( posedge clk or negedge rst_n ) begin
        if( !rst_n )
            data_current <= 1'b0;
        else
            data_current <= data_next;
    end
 
endmodule


`timescale 1ns/1ns
`define clock_period 20
 
module FSM_gener_tb();
 
    reg                    clk;
    reg                    rst_n;
    wire                data_current;
 
    FSM_gener FSM_gener0
    (
        .clk(clk),
        .rst_n(rst_n),
        
        .data_current(data_current)
    );
    
    initial begin clk = 1'b1; end
    always#( `clock_period )    clk = ~clk;
    
    initial begin
        rst_n = 0;
        #( `clock_period*10  );
        rst_n = 1;        
        #( `clock_period*10 + 1'b1 );
        #( `clock_period*50 );
        $stop;
    end
 
endmodule

连续序列1101检测案例

2.1 需求分析

（1）检测任意数字序列，若连续出现1101则表示检测到目标序列命令，输出标识信号flag，此处以“11101101011010”为例，设计三段式FSM进行检测。

（2）其状态转移图如下所示，一共分为5个状态，IDEL下状态为xxxx未知态，同理S1：1xxx S2：11xx S3：110x S4：1101

（3）单次循环有四种链路传输状态：

1）首先最简单的链路就是输入d_in连续检测成功，第一拍为d_in = 1'b1，依次分别为1'b1、1'b0、 1'b1，进入S4后在下一拍检测到d_in = 1'b0，则返回IDEL准备新一轮检测。

2）其次，有可能在S1和S3检测到d_in = 1'b0返回IDEL。

3）最后，抵达S4后如果下一拍上升沿检测到d_in = 1’b1,则返回S2，当时状态为11xx。


module FSM_1101(
    input                        clk,
    input                        rst_n,
    input                     FSM_1101_in,      //一位输入
    
    output reg                 Match_Flag            //1101检测成功标志信号
);
    //***********************parameter************************
    reg [2:0] next_state;            //下一拍执行状态
    reg [2:0] state;                    //当前拍未执行最新状态
        
    localparam                            //一共五个状态，使用Gray码提高翻转效率
        IDEL      = 3'b000,
        NUM_1xxx = 3'b001,
        NUM_11xx = 3'b011,
        NUM_110x = 3'b010,
        NUM_1101 = 3'b110;          //110=>000翻转了两位，不够好
        
    //***********************FSM 1101************************
    //第一段 下一状态更新
    always@( posedge clk or negedge rst_n ) begin
        if( !rst_n )
            next_state <= IDEL;
        else
            next_state <= state;
    end
    
    //第二段 状态判断跳转
    always@(*) begin
        case(next_state)
            IDEL:     begin
                        if( FSM_1101_in == 1'b1 )
                            state <= NUM_1xxx;
                        else
                            state <= IDEL;
                     end
            NUM_1xxx:begin
                        if( FSM_1101_in == 1'b1 )
                            state <= NUM_11xx;
                        else
                            state <= IDEL;
                     end
            NUM_11xx:begin
                        if( FSM_1101_in == 1'b0 )
                            state <= NUM_110x;
                        else
                            state <= NUM_11xx;
                     end
            NUM_110x:begin
                        if( FSM_1101_in == 1'b1 )
                            state <= NUM_1101;
                        else
                            state <= IDEL;
                     end
            NUM_1101:begin
                        if( FSM_1101_in == 1'b1 )
                            state <= NUM_11xx;
                        else
                            state <= IDEL;
                     end
            default:state <= IDEL;
        endcase
    end
    
    //第三段 标志信号输出
    always@( posedge clk or negedge rst_n ) begin
        if( !rst_n )
            Match_Flag <= 0;
        else if( next_state == NUM_1101 )
            Match_Flag <= 1'b1;
        else 
            Match_Flag <= 1'b0; 
    end
    
endmodule


`timescale 1ns/1ns
`define clock_period 20
 
module FSM_1101_tb();
    
    //参数
    reg clk;
    reg rst_n;
    reg FSM_1101_in;
    wire Match_Flag;
 
    //调用
    FSM_1101 FSM_1101
    (
        .clk(clk),
        .rst_n(rst_n),
        .FSM_1101_in(FSM_1101_in),      //一位输入
        
        .Match_Flag(Match_Flag)            //1101检测成功标志信号
    );
 
    //Initial
    initial 
        begin
            clk = 1;
            rst_n = 0;
            FSM_1101_in = 0;
        end
    
    //Clock
    always#(`clock_period/2) clk = ~clk;
    
    //1101101011010 Generate
    initial begin
        #( `clock_period*20 );
        rst_n = 1;
        #( `clock_period*20 + 1'b1 );
        FSM_1101_in = 1;
        #( `clock_period );
        FSM_1101_in = 1;
        #( `clock_period );
        FSM_1101_in = 0;
        #( `clock_period );
        FSM_1101_in = 1;
        #( `clock_period );
        FSM_1101_in = 1;
        #( `clock_period );
        FSM_1101_in = 0;
        #( `clock_period );
        FSM_1101_in = 1;
        #( `clock_period );
        FSM_1101_in = 0;
        #( `clock_period );
        FSM_1101_in = 1;
        #( `clock_period );
        FSM_1101_in = 1;
        #( `clock_period );
        FSM_1101_in = 0;
        #( `clock_period );
        FSM_1101_in = 1;
        #( `clock_period );
        FSM_1101_in = 0;
        
        #( `clock_period*50 );
        $stop;
    end
endmodule

// 数字电路面试题目笔记 https://blog.csdn.net/H19981118/article/details/125071753

用Moore型状态机实现序列“1101”从右到左的不重叠检测。

1、请画出状态转移图，其中状态用S1,S2,…来标识。

2、针对这个具体设计，如何衡量验证的完备性？

Moore型：状态机的状态变化仅和当前状态有关。

Mealy型：不仅和当前状态有关，也和输入有关。


//序列检测器1011,不重叠检测
 
module test(
    
     input clk,
     input rst_n,
     input d,         //序列输入
     output reg done  //检测完成
);
parameter S1 = 3'd1,S2 = 3'd2,S3 = 3'd3,S4 = 3'd4,S5 = 3'd5;
 
reg [2:0] state,next_state;
 
 
//三段式状态机
 
//第一段，状态寄存器
always@(posedge clk)
    if(!rst_n)
         state <= S1;
     else
         state <= next_state;
          
//第二段，组合逻辑描述状态转移
always @ (*)begin
    case(state)
          S1: next_state = d ? S2:S1;
          S2: next_state = d ? S2:S3;
          S3: next_state = d ? S4:S1;
          S4: next_state = d ? S5:S3;
          S5: next_state = d ? S2:S1;
          default: next_state = S1;
    
    endcase
end      
//第三段，状态输出
always@(*)
    done = (state == S5) ;
 
endmodule

可重叠的代码差不多，自己✍


`timescale 1ns/1ns
 
module test_tb;
 
     reg clk;
     reg rst_n;
     reg d;        //序列输入
     
     wire done ; //检测完成
 
 
 
 test u1 (
    
     .clk(clk),
     .rst_n(rst_n),
     .d(d),         //序列输入
     .done(done) //检测完成
);
//
initial clk = 0;
    always #1 clk = ~clk;
//
initial begin
    rst_n = 0;
    #1;
    rst_n = 1;
end
//
initial begin
    d = 0;
    #2;
    d = 1;
    #2;
    d = 0;     
    #2;
    d = 1;
     #2;
    d = 1;
     
    #2;
     d = 0;
     #2;
    d = 1;
     #2;
    d = 1;
     #3;
     d= 0;
     #20;
     $stop;
          
end
 
endmodule

用移位操作实现循环序列发生器

题目要求：

循环产生如下序列：0010_1101_11。

解题：可采用状态机实现，但为了简化操作，这里采用移位操作来实现序列的循环发生


module test(
    
    input clk,
    input rst_n,
     input [9:0] in,
     
    output reg out
);
 
    reg [9:0] out_r;
     
//移位
    always@(posedge clk or negedge rst_n) 
         if(!rst_n)
              out_r <= in;  //0010_1101_11
 
          else 
             
                out_r <= {out_r[8:0],out_r[9] };
 
//逐高位输出          
    always@(posedge clk or negedge rst_n) 
         if(!rst_n)
              out <= 0;
    
          else 
              out <= out_r[9];
 
endmodule


`timescale 1ns/1ns
 
module test_tb;
 
     reg clk;
     reg rst_n;
     reg [9:0] in;
 
     wire out ; //检测完成
 
 
 
 test u1 (
    
     .clk(clk),
     .rst_n(rst_n),
     .in(in),
     .out(out)
);
 
initial clk = 0;
    always #1 clk = ~clk;
 
initial begin
    rst_n= 0;
     in = 10'b0010_1101_11;
    #10;
    rst_n= 1;
     #5;  
 
     #50;
 
     $stop;
end
 
endmodule

如何衡量设备的完备性

设备完备性的衡量是用来验证的，对于状态机来说，会出现各种状态跳转错误等，因此我们要确保状态之间的正确跳转，同时本题中是不重叠检测，因此也要明确这点，确保当出现重叠序列的时候，不会误检。另外可以从定向测试、随机测试两种方式产生激励，从代码覆盖率的角度保证覆盖率达到100%。

最高工作频率与最小工作周期

找到电路的关键路径。

同时最小工作周期公式：Tmin = Tco + Tcmob + Tsu - Tskew。

组合逻辑电路则最小工作周期：Tmin = Tco + Tcmob + Tsu。

本题中，Tco为触发器输出的延时，为这里的逻辑延时6ns，组合逻辑的延时为反相器INV2的延时2ns，Tsu为建立时间2ns。这里没有考虑INV1的延迟，因为关键路径的延迟是从源触发器的Tco开始算。

因此最小工作周期 Tmin = 6 + 2 +2 = 10ns。

最高工作频率 = 1 / 10ns = 0.1 GHZ = 100 MHZ

补充：1ns = 10^-9 s

跨时钟域处理——格雷码

在前面的笔记中，我们已经详细介绍了握手信号等，这里主要介绍跨时钟域处理中的格雷码。

格雷码：可以解决多bit跨时钟域信号传输。

本题目中第四种方法不常见，自己也不太懂，可参考其他博文的解释，我这里主要来分析第三种格雷码的方式。

格雷码：相邻的两个编码之间只有一位是不一样的。

独热码：每个编码只有一位是1。

为什么格雷码能用于跨时钟域处理？

由于格雷码相邻数据只有一个bit不同，因此，在进行跨时钟域传输时，只有发生变化的那个bit有可能处于亚稳态，而其余bit保持不变，因此是稳定的，故多比特格雷码的跨时钟域传输就相当于单比特信号的跨时钟域传输，这样的话，我们即可采用两级同步来处理。

但本题中是0-6的计数，对应的二进制码和格雷码如下，可看到转换后不符合题目0-6的要求，因此不能用格雷码

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/915730

Verilog状态机_verilog 状态机

状态机基本概念：

FSM实现实现11010110序列输出

用移位操作实现循环序列发生器

跨时钟域处理——格雷码