HDLBits(十)学习笔记——有限状态机（FSM1 - Lemmings4）

最新推荐文章于 2024-07-21 22:19:49 发布
最新推荐文章于 2024-07-21 22:19:49 发布
阅读量1.3k 收藏 3
点赞数 4
分类专栏： HDL Bits 学习 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H19981118/article/details/124175713
版权
本文详细解读了Fsm1-Fsm4的状态机设计，包括摩尔状态机和米利状态机的区别，异步/同步复位的实现，独热码编码，以及复杂场景如Lemmings系列状态机的模拟。重点展示了组合逻辑、输出逻辑和状态编码技巧。
摘要由CSDN通过智能技术生成

文章目录


状态机的写法以及独热码
摩尔状态机与米利状态机的区别

Fsm1(异步复位)

该题状态机为摩尔状态机，其状态机的状态变化仅和当前状态有关。采用异步重置且重置状态为 B。
在这里插入图片描述

module top_module(
    input clk,
    input areset,    // Asynchronous reset to state B
    input in,
    output out
);
//三段式状态机
    //第一段，描述状态转移
    parameter A=0;
    parameter B=1; 
    reg state_c;
    reg state_n;
    
    always @(posedge clk or posedge areset)
        if(areset)begin
            state_c <= B;
        end
        else begin
            state_c <= state_n;
        end
    //第二段，描述状态转移规律
    always @(*)begin
        case(state_c)
            B:begin
                if(in == 1)
                    state_n = B;
                else
                    state_n = A;
            end
            A: begin
                 if(in == 1)
                    state_n = A;
                else
                    state_n = B;
            end
        endcase
    end
    //第三段描述输出
    //always@(*) //采用always块，那么块中的变量要定义成reg型，可给出的out默认wire，因此直接用赋值语句
    assign out = (state_c == B) ? 1: 0;
    
endmodule

Fsm1s(同步复位)

和上题类似，只不过采用同步复位在这里插入图片描述


module top_module(clk, reset, in, out);
    input clk;
    input reset;    // Synchronous reset to state B
    input in;
    output out;//  
    reg out;

    // Fill in state name declarations
    parameter A = 0;
    parameter B = 1;


    reg present_state, next_state;
    
//状态转移
    always @(posedge clk) begin
        if (reset) begin  
            // Fill in reset logic
            present_state <= B;
        end 
        else begin
            present_state <= next_state;
        end
    end
//描述状态转移规律（根据当前状态来判断下一状态）
        always @ (*)begin
            case(present_state)
                B:begin
                    if(in == 0)
                        next_state = A;
                    else
                        next_state = B;
                end
                A:begin
                    if(in == 0)
                        next_state = B;
                    else
                        next_state = A;
                end
            endcase
        end
//描述输出
          always @(*) begin
              if(present_state == A)
                  out = 0;
              else
                  out = 1;
       end
            
   
endmodule

FSM2（异步复位）

这是一个摩尔状态机，具有两个状态、两个输入和一个输出。实现此状态机，同时使用异步重置。在这里插入图片描述

//三段式状态机的写法
module top_module(
    input clk,
    input areset,    // Asynchronous reset to OFF
    input j,
    input k,
    output out); 
    
//parameter声明全局常量
    parameter OFF=0;
    parameter ON= 1; 
    
    reg state, next_state;

//描述状态转移
    always @(posedge clk, posedge areset) begin
        // State flip-flops with asynchronous reset
        if(areset)
            state <= OFF;
        else
            state <= next_state;
    end
    
//组合逻辑描述状态转移规律
     always @(*) begin
        // State transition logic
         case(state)
             OFF:begin
                 if(j == 1)
                     next_state = ON;
                 else
                     next_state = OFF;
             end
             ON:begin
                 if(k == 1)
                    next_state = OFF;
                 else
                    next_state = ON; 
             end
         endcase
    end
   
//描述输出    

    assign out = (state == ON) ? 1 : 0;

endmodule

//两段式状态机的写法
module top_module(
    input clk,
    input areset,    // Asynchronous reset to OFF
    input j,
    input k,
    output out); 
    
//parameter声明全局常量
    parameter OFF=0;
    parameter ON= 1; 
    
    reg state, next_state;
    
//第一段：描述状态转移
    always @(posedge clk, posedge areset) begin
        // State flip-flops with asynchronous reset
        if(areset)
            state <= OFF;
        else
            state <= next_state;
    end
    
//第二段：采用组合逻辑描述状态转移规律以及输出
     always @(*) begin
        // State transition logic
         case(state)
             OFF:begin
                 if(j == 1)begin
                     next_state = ON;
                     out = 0;
                 end
                 else begin
                     next_state = OFF;
                     out = 0;
                 end
             end
             ON:begin
                 
                 if(k == 1)begin
                    next_state = OFF;
                    out = 1;
                 end
                 
                 else begin
                    next_state = ON; 
                    out = 1;
                 end
             end
         endcase
    end
   

endmodule

Fsm2s（同步复位）

和Fsm2相同，不过采用同步复位。
在这里插入图片描述
如下写法的重点在于：
一 采用了独热码编码的方式对状态进行编码
二 采用三段式状态机

module top_module(
    input clk,
    input reset,    // Synchronous reset to OFF
    input j,
    input k,
    output out); //  

    parameter OFF= 2'b01;
    parameter ON=  2'b10; 
    
    reg [1:0]state, next_state;
    
//第一段状态转移
        
    always @(posedge clk) begin
        // State flip-flops with synchronous reset
        if(reset)
            state <= OFF;
        else
           state <= next_state; 
    end
    
//第二段描述状态转移规律
    always @(*) begin
        // State transition logic
        case(state)
            OFF:begin
                if(j == 1)
                    next_state = ON;
                else
                    next_state = OFF;
            end
            ON:begin
                if(k == 1)
                    next_state = OFF;
                else
                    next_state = ON;
            end
        endcase       
    end

//第三段描述输出
    assign out = (state == ON) ? 1 : 0;

endmodule

Fsm3comb （仅实现组合逻辑部分）

以下是具有一个输入、一个输出和四个状态的 摩尔 状态机的状态转换表。
使用以下状态编码：A=2’b00，B=2’b01，C=2’b10，D=2’b11。
**仅实现此状态机的状态转换逻辑和输出逻辑（组合逻辑部分）。**给定当前状态 ，根据状态转换表计算下一状态 和 输出
在这里插入图片描述
此题相当于只写三段式状态机的后两段，无需描述状态转移，只采用组合逻辑描述状态转移规律以及输出

module top_module(
    input in,
    input [1:0] state,
    output [1:0] next_state,
    output out); 
    
//声明全局变量
    parameter A= 2'b00;
    parameter B= 2'b01;
    parameter C= 2'b10;
    parameter D= 2'b11;
//仅实现之前三段式写法中的第二三段
//用组合逻辑实现状态转移规律以及输出
    
//组合逻辑实现状态转移规律    
    always @ (*)begin
        case(state)
            A:begin
                if(in == 1)
                    next_state = B;
                else
                    next_state = A;
            end
            B:begin
                if(in == 0)
                    next_state = C;
                else
                    next_state = B;
            end
            C:begin
                if(in == 1)
                    next_state = D;      
                else
                    next_state = A; 
            end
            D:begin
                if(in == 1)
                    next_state = B;      
                else
                    next_state = C;                 
            end
        endcase
    end
    
//描述输出
    assign out = (state == D) ? 1 : 0;

endmodule

Fsm3onehot（独热码编码方式）

题目：
以下是具有一个输入、一个输出和四个状态的 摩尔状态机的状态转换表。使用以下单热状态编码：A=4’b0001，B=4’b0010，C=4’b0100，D=4’b1000。

通过检测假设采用独热编码来推导状态转换和输出逻辑方程。仅实现此状态机的状态转换逻辑和输出逻辑（组合逻辑部分）。
在这里插入图片描述
题目分析：
首先掌握什么是独热码
状态机编码：
独热码、格雷码，其中使用独热码永远只有一个位为1，即可保持位的变化少，但是用独热码后会有多余的状态，于是在写case语句时，需要要加上default的情况，不然的话，会生成锁存器。其中default分支可以用默认项表示，也可以用确定向来表示，以确保能最初状态。

该题目与 Fsm3comb题目的 不同就在于本题采用独热码进行编码。

module top_module(
    input in,
    input [3:0] state,
    output [3:0] next_state,
    output out); //

    parameter A=0;
    parameter B=1;
    parameter C=2;
    parameter D=3;

    // State transition logic: Derive an equation for each state flip-flop.
    assign next_state[A] = (state[A]&~in) | (state[C] & ~in);
    assign next_state[B] = (state[A]&in) | (state[D]&in) | (state[B]&in);
    assign next_state[C] = (state[B]&~in) | (state[D]&~in);
    assign next_state[D] = (state[C]&in);

    // Output logic: 
    assign out = (state[D]); //表示只有D状态的时候，输出为1

endmodule

Fsm3（async异步复位）

实现此状态机，将 FSM 重置为状态 A 的异步重置
在这里插入图片描述

module top_module(
    input clk,
    input in,
    input areset,
    output out
);

    reg [3:0] state;
    reg [3:0] next_state;
    
//声明全局变量
    parameter A= 4'b0001;
    parameter B= 4'b0010;
    parameter C= 4'b0100;
    parameter D= 4'b1000;
    
//第一段，状态转移
    always @ (posedge clk or posedge areset)begin
        if(areset)
            state <= A;
        else
            state <= next_state;
    end

    
//第二段，组合逻辑实现状态转移规律    
    always @ (*)begin
        case(state)
            A:begin
                if(in == 1)
                    next_state = B;
                else
                    next_state = A;
            end
            B:begin
                if(in == 0)
                    next_state = C;
                else
                    next_state = B;
            end
            C:begin
                if(in == 1)
                    next_state = D;      
                else
                    next_state = A; 
            end
            D:begin
                if(in == 1)
                    next_state = B;      
                else
                    next_state = C;                 
            end
        endcase
    end
    
    
//描述输出
    assign out = (state == D) ? 1 : 0;

endmodule

Fsm3（sync同步复位）

和上题的区别仅在于之前的异步复位变为了同步复位

module top_module(
    input clk,
    input in,
    input reset,
    output out
);

    reg [3:0] state;
    reg [3:0] next_state;
    
//声明全局变量
    parameter A= 4'b0001;
    parameter B= 4'b0010;
    parameter C= 4'b0100;
    parameter D= 4'b1000;
    
//第一段，状态转移
    always @ (posedge clk)begin
        if(reset)
            state <= A;
        else
            state <= next_state;
    end

    
//第二段，组合逻辑实现状态转移规律    
    always @ (*)begin
        case(state)
            A:begin
                if(in == 1)
                    next_state = B;
                else
                    next_state = A;
            end
            B:begin
                if(in == 0)
                    next_state = C;
                else
                    next_state = B;
            end
            C:begin
                if(in == 1)
                    next_state = D;      
                else
                    next_state = A; 
            end
            D:begin
                if(in == 1)
                    next_state = B;      
                else
                    next_state = C;                 
            end
        endcase
    end
    
    
//描述输出
    assign out = (state == D) ? 1 : 0;

endmodule

Design a Moore FSM

该题目采用同步高电平复位。
共包含六个状态，四个水位状态，以及两个补充流量状态。四个水位状态分别为如下表格的四种情况。两个补充状态分别是B的流量补充，以及C的流量补充。
在这里插入图片描述
状态转换图：在这里插入图片描述

module top_module (
    input clk,
    input reset,
    input [3:1] s,
    output fr3,
    output fr2,
    output fr1,
    output dfr
); 
    reg [5:0] state;
    reg [5:0] next_state;
//声明全局变量,独热码编码
    parameter   A=    6'b000001;
    parameter   B=    6'b000010;
    parameter   C=    6'b000100;
    parameter   D=    6'b001000;
    parameter B_drop= 6'b010000;
    parameter C_drop= 6'b100000;
    
//第一段，状态转移
    always @ (posedge clk)begin
        if(reset)
            state <= A;
        else
            state <= next_state;
    end
//第二段，组合逻辑实现状态转移规律
    always @ (*)begin
        case(state)
            A:begin
                next_state = s[1] ? B : A;
            end
            B:begin
                next_state = s[2] ? C : (s[1] ? B : A);
            end
            C:begin
                next_state = s[3] ? D : (s[2] ? C : B_drop);
            end
            D:begin
                next_state = s[3] ? D : C_drop;
            end
            B_drop:begin
                next_state = s[2] ? C : (s[1] ? B_drop : A);
            end
            C_drop:begin
                next_state = s[3] ? D : (s[2] ? C_drop : B_drop);
            end
            default: next_state =  A;
        endcase
        end
//第三段，组合逻辑描述输出
    always @ (*) begin
        case(state)
            A:       {fr1,fr2,fr3,dfr} = 4'b1111;
            B:       {fr1,fr2,fr3,dfr} = 4'b1100;
            C:       {fr1,fr2,fr3,dfr} = 4'b1000;
            D:       {fr1,fr2,fr3,dfr} = 4'b0000;
            B_drop:  {fr1,fr2,fr3,dfr} = 4'b1101;
            C_drop:  {fr1,fr2,fr3,dfr} = 4'b1001;
            default: {fr1,fr2,fr3,dfr} = 4'b0000;
        endcase
    end
endmodule

Lemmings1

在Lemmings的2D世界中，Lemmings可以处于以下两种状态之一：向左行走或向右行走。如果它碰到障碍物，它会改变方向。特别是，如果一只旅鼠在左边被撞到，它会向右走。如果它在右边被撞到，它将向左走。如果它同时在两侧碰撞，它仍然会改变方向。

实现具有两个状态、两个输入和一个输出的摩尔状态机，用于模拟此行为。在这里插入图片描述
该题目是异步复位。
状态分析：
在这里插入图片描述

module top_module(
    input clk,
    input areset,    // Freshly brainwashed Lemmings walk left.
    input bump_left,
    input bump_right,
    output walk_left,
    output walk_right
); 

    parameter LEFT =2'b01;
    parameter RIGHT=2'b10;
    
    reg [1:0 ]state, next_state;
    reg [1:0 ] bump ;
    assign bump = {bump_left,bump_right};
 // 第一段，状态转移
    always @(posedge clk or posedge areset) begin
        if(areset)begin
            state <= LEFT;
        end
        else begin
            state <= next_state;
        end
 end
//第二段，组合逻辑描述输入
    always @(*) begin
        case(state)
            
            LEFT:begin
                if(bump == 2'b00 || bump == 2'b01)
                    next_state = LEFT;
                else
                    next_state = RIGHT;
            end
            RIGHT:begin
                if(bump == 2'b11 || bump == 2'b01)
                    next_state = LEFT;
                else
                    next_state = RIGHT;
            end
        endcase

    end

//组合逻辑描述输出
    assign walk_left = (state == LEFT) ? 1: 0;
    assign walk_right = (state == RIGHT) ? 1 : 0;

endmodule

Lemmings2

除了左右走动之外，如果脚下的土地消失，莱明斯还会摔倒（大概还会掉下来“啊！”）。

除了左右行走以及在颠簸时改变方向外，当ground=0时，旅鼠会摔倒并说“啊啊！当地面重新出现（ground=1）时，旅鼠将恢复向与坠落前相同的方向行走。在跌倒时被撞击不会影响行走方向，在与地面相同的周期中被撞击消失（但尚未下落），或者当地面在仍然下落时重新出现时，也不会影响行走方向。
构建一个有限状态机来模拟这种行为。
在这里插入图片描述

module top_module(
    input clk,
    input areset,    // Freshly brainwashed Lemmings walk left.
    input bump_left,
    input bump_right,
    input ground,
    output walk_left,
    output walk_right,
    output aaah 
); 
    
    parameter LEFT = 4'b0001;
    parameter RIGHT = 4'b0010;
    parameter GR_LEFT = 4'b0100; //坠落后左走状态
    parameter GR_RIGHT = 4'b1000;//坠落后右走状态
    
    reg [3:0] state,next_state;
    wire [1:0] bump;
    assign bump = {bump_left,bump_right};
    
    always @(*)begin
        case(state)
        	LEFT:begin
                if(ground == 1'b0)begin //地面消失进入坠落左走状态
                	next_state <= GR_LEFT;
                end
                else if((bump == 2'b10) || (bump == 2'b11))begin
                    next_state <= RIGHT;
                end
                else begin
                    next_state <= LEFT;
                end
            end
            RIGHT:begin
                if(ground == 1'b0)begin //地面消失进入坠落右走状态
                    next_state <= GR_RIGHT;
                end
                else if((bump == 2'b01) || (bump == 2'b11))begin
                    next_state <= LEFT;
                end
                else begin
                	next_state <= RIGHT;
                end
            end
            GR_LEFT:begin  //坠落左走状态的地面恢复时，则继续左走
                if(ground == 1'b0)begin
                	next_state <= GR_LEFT;
                end
                else begin
                	next_state <= LEFT;
                end
            end
            GR_RIGHT:begin//坠落右走状态的地面恢复时，则继续右走
                if(ground == 1'b0)begin
                	next_state <= GR_RIGHT;
                end
                else begin
                	next_state <= RIGHT;
                end
            end
        endcase
    end
    
    always@(posedge clk,posedge areset)begin
        if(areset)begin
            state <= LEFT;
        end
        else begin
            state <= next_state;
        end
    end
    
    assign walk_left = (state == LEFT);
    assign walk_right = (state == RIGHT);
    assign aaah = ((state == GR_LEFT) | (state == GR_RIGHT));  //不管是坠落的左走右走，只要坠落就会啊啊

endmodule

Lemmings3

除了走路和坠落之外，旅鼠有时还可以被告知做一些有用的事情，比如挖掘（当dig=1时开始挖掘）。如果旅鼠目前在地面上行走（地面=1且未掉落），则可以挖掘，并将继续挖掘，直到到达另一侧（地面=0）。在这一点上，由于没有地面，它会掉下来（啊！），然后一旦它再次落地，继续向原来的方向走。与跌倒一样，在挖掘时被撞到没有效果，并且在跌倒或没有地面时被告知要挖洞是被忽略的。

（换句话说，行走的旅鼠可以摔倒，挖掘或改变方向。如果满足这些条件中的多个条件，则 坠落的优先级高于 挖掘，挖掘 的优先级高于切换方向。）

扩展有限状态机以对此行为进行建模。在这里插入图片描述
题目分析，该题目的走路切换方向以及坠落和前面的两个题目是相同的，只是加入了挖掘功能，挖掘跟地面ground有关，地面消失则坠落，地面存在则继续挖掘。另外是优先级的问题。坠落 》 挖掘 》 走路切换方向

if(ground)
else if (dig)
else(bump)
else

下面为状态转移图：
在这里插入图片描述

module top_module(
    input clk,
    input areset,    // Freshly brainwashed Lemmings walk left.
    input bump_left,
    input bump_right,
    input ground,
    input dig,
    output walk_left,
    output walk_right,
    output aaah,
    output digging 
); 


    
    parameter LEFT      =  6'b000001;
    parameter RIGHT     =  6'b000010;
    parameter GR_LEFT   =  6'b000100; //坠落后左走状态
    parameter GR_RIGHT  =  6'b001000; //坠落后右走状态
    parameter Dig_LEFT =   6'b010000;
    parameter Dig_RIGHT =  6'b100000;
    
    
    reg [5:0] state,next_state;
    wire [1:0] bump;
    assign bump = {bump_left,bump_right};
    
    always @(*)begin
        case(state)
        	LEFT:begin
                if(ground == 1'b0) //地面消失进入坠落左走状态
                	next_state <= GR_LEFT;  
                else if(dig == 1'b1) 
                    next_state <= Dig_LEFT;            
                else if((bump == 2'b10) || (bump == 2'b11))
                    next_state <= RIGHT;      
                else 
                    next_state <= LEFT;        
            end
            RIGHT:begin
                if(ground == 1'b0) //地面消失进入坠落右走状态
                    next_state <= GR_RIGHT;
                else if(dig == 1'b1)
                    next_state <= Dig_RIGHT;
                else if((bump == 2'b01) || (bump == 2'b11))
                    next_state <= LEFT;
                else 
                	next_state <= RIGHT;
            end
            GR_LEFT:begin  //坠落左走状态的地面恢复时，则继续左走
                if(ground == 1'b0)
                	next_state <= GR_LEFT;
                else begin
                	next_state <= LEFT;
                end
            end
            GR_RIGHT:begin//坠落右走状态的地面恢复时，则继续右走
                if(ground == 1'b0)
                	next_state <= GR_RIGHT;
                else 
                	next_state <= RIGHT;
            end
           Dig_LEFT:begin
               if(ground == 1'b0)//挖空
                   next_state <= GR_LEFT;
               else 
                   next_state <= Dig_LEFT;
           end
           Dig_RIGHT:begin
               if(ground == 1'b0)
                   next_state <= GR_RIGHT;
               else 
                   next_state <= Dig_RIGHT;
           end    
        endcase
    end
    
    always@(posedge clk or posedge areset)begin
        if(areset)begin
            state <= LEFT;
        end
        else begin
            state <= next_state;
        end
    end
    
    assign walk_left = (state == LEFT);
    assign walk_right = (state == RIGHT);
    assign aaah = ((state == GR_LEFT) | (state == GR_RIGHT)) ? 1 : 0;  //不管是坠落的左走右走，只要坠落就会啊啊
    assign digging = ((state == Dig_LEFT) | (state == Dig_RIGHT)) ? 1 : 0; 

endmodule

Lemmings4

虽然旅鼠可以走路、摔倒和挖掘，但旅鼠并非无懈可击。如果旅鼠坠落太久然后撞到地面，它可能会飞溅（死亡）。特别是，如果一只旅鼠坠落超过20个时钟周期，然后撞到地面，它将飞溅并停止行走，坠落或挖掘（所有4个输出变为0），永远（或直到FSM被重置）。旅鼠在落地前可以跌落多远没有上限。旅鼠只有在撞击地面时才会飞溅;它们不会在半空中飞溅。

扩展有限状态机以对此行为进行建模。
在这里插入图片描述
该题目结合了前面三个题目，在此基础上加入了飞溅死亡功能。当坠落超过20个时钟周期，且碰到地面的时候飞溅，没碰到地面不飞溅。
因此需要加入一个空中和飞溅死亡状态。其空中状态由是否超过20个时钟周期来决定，而飞剑死亡状态的转换条件由输入是否碰到地面来决定。另外还需要设计一个计数器，只要下一状态是左右坠落就进行计数，否则计数为0，便于我们在坠落的基础上根据坠落时间来判断下一状态的转换。
优先级仍然是 坠落 》 挖掘 》左右走路方向
在这里插入图片描述

module top_module(
    input clk,
    input areset,    // Freshly brainwashed Lemmings walk left.
    input bump_left,
    input bump_right,
    input ground,
    input dig,
    output walk_left,
    output walk_right,
    output aaah,
    output digging 
); 
    
    reg [4:0] count;
    wire [1:0] bump;
    reg [7:0] state;
    reg [7:0] next_state;
    
    assign bump = {bump_left,bump_right};
    
//独热码进行八种状态的定义
    parameter LEFT      = 8'b00000001; //左右走的方向
    parameter RIGHT     = 8'b00000010;
    parameter GR_LEFT   = 8'b00000100; //左右坠落
    parameter GR_RIGHT  = 8'b00001000;
    parameter Dig_LEFT  = 8'b00010000;
    parameter Dig_RIGHT = 8'b00100000;
    parameter Fall_air  = 8'b01000000;
    parameter Dead      = 8'b10000000;
    
//第一段 状态转换
    always @ (posedge clk or posedge areset)begin
        if(areset)
            state <= LEFT;
        else
            state <= next_state;
    end
//第二段 采用组合逻辑描述下一状态跳转
    always @ (*)begin
        case(state)
            LEFT:begin
                if(ground == 1'b0) //地面消失进行坠落状态
                    next_state = GR_LEFT;
                else if(dig == 1'b1) //地面存在但启动挖掘功能
                    next_state = Dig_LEFT;
                else if(bump == 2'b10 || bump == 2'b11) //左右走
                    next_state = RIGHT;
                else
                    next_state = LEFT;
            end
            RIGHT:begin
                if(ground == 1'b0) //地面消失进行坠落状态
                    next_state = GR_RIGHT;
                else if(dig == 1'b1) //地面存在且启动挖掘功能
                    next_state = Dig_RIGHT;
                else if(bump == 2'b01 || bump == 2'b11)//左右走
                    next_state = LEFT;
                else
                    next_state = RIGHT;
            end
            GR_LEFT:begin
                if((ground == 1'b0) && (count < 5'd20)) //地面消失坠落且坠落时间小于20个时钟周期
                    next_state = GR_LEFT;
                else if((ground == 1'b0) && (count >= 5'd20)) //地面消失坠落且坠落时间大于20个时钟周期
                    next_state = Fall_air;
                else  //否则复位
                    next_state = LEFT;
            end
            GR_RIGHT:begin
                if((ground == 1'b0) && (count < 5'd20)) //地面消失坠落且坠落时间小于20个时钟周期
                    next_state = GR_RIGHT;
                else if((ground == 1'b0) && (count >= 5'd20)) //地面消失坠落且坠落时间大于20个时钟周期
                    next_state = Fall_air;
                else  //否则复位
                    next_state = RIGHT;
            end
            Dig_LEFT:begin
                if(ground == 1'b0)
                    next_state = GR_LEFT;
                else
                    next_state = Dig_LEFT;
            end
            Dig_RIGHT:begin
                if(ground == 1'b0)
                    next_state = GR_RIGHT;
                else
                    next_state = Dig_RIGHT;
            end
            Fall_air:begin
                if(ground == 1'b1) //碰到地面死掉，没碰到地面则仍在空中
                    next_state = Dead;
                else
                    next_state = Fall_air;
            end
            Dead:
                next_state = Dead;
        endcase
    end
 //第三段，组合逻辑描述输出
    assign walk_left = (state == LEFT);
    assign walk_right = (state == RIGHT);
    assign aaah = ((state == GR_LEFT) || (state == GR_RIGHT) || (state == Fall_air));
    assign digging = ((state == Dig_LEFT) || (state == Dig_RIGHT));
  
    
    //设计计数器   (计数至少21次，五位位宽即可)
    always @ (posedge clk or posedge areset)begin
        if(areset)
            count <= 0;
        else if ((next_state == GR_LEFT) ||(next_state == GR_RIGHT) )
            count <= count + 1'b1;
        else
            count <= 0;
    end
endmodule

本次主要学习三段式状态机的写法，以及独热码的编码方式。

Fighting_FPGA
关注
专栏目录
Verilog HDLbits:Lemmings4（Moore型有限元状态机）
m0_46272475的博客
10-26 928
题目 Although Lemmings can walk, fall, and dig, Lemmings aren’t invulnerable. If a Lemming falls for too long then hits the ground, it can splatter. In particular, if a Lemming falls for more than 20 clock cycles then hits the ground, it will splatter and ce
Lemmings4
Squirrel_fish的博客
11-15 560
题目 See also:Lemmings1,Lemmings2, andLemmings3.Although Lemmings can walk, fall, and dig, Lemmings aren't invulnerable. If a Lemming falls for too long then hits the ground, it can splatter. In particular, if a Lemming falls for more than 20 clock cycle...
Verilog刷题笔记49——Fsm1同步复位
shikuanlong的博客
06-26 280
同步复位FSM1
HDLBits答案（2）_状态机（1）
最新发布
学无止境_hjy的博客
07-21 775
今天刷完状态机的1/3，以下是书写的代码。
HDLBITS笔记31：有限状态机一（FSM1、FSM1S、FSM2、FSM2S)
weixin_46817835的博客
04-22 4255
题目1：FSM1 这是一个摩尔状态机，具有两个状态，一个输入和一个输出。实现此状态机。请注意，重置状态为 B。 此练习与fsm1s，但使用异步重置。 模块声明 module top_module( input clk, input areset, // Asynchronous reset to state B input in, output out); ...
Fsm1_hdlbits
anbncn1234的博客
05-17 602
状态机学习link： https://wenku.baidu.com/view/9e44f7650066f5335a8121e3.html module top_module( input clk, input areset, // Asynchronous reset to state B input in, output out);// parameter A=0, B=1; reg state, next_state; alway
HDLBits练习-有限状态机(FSM)（5）
weixin_43723684的博客
05-21 278
HDLBits练习 Circuits-Sequential Logic-Finite State Machines（5） 题25：Q3b: FSM module top_module ( input clk, input reset, // Synchronous reset input x, output z ); reg [2:0]state,next_state; always@(*)begin case(state)
HDLBits练习-有限状态机(FSM)（3）
weixin_43723684的博客
05-06 233
HDLBits练习 Circuits-Sequential Logic-Finite State Machines（3） 题14：One-hot FSM module top_module( input in, input [9:0] state, output [9:0] next_state, output out1, output out2); assign next_state[0]=~in & (|{state[4:0], state[9:7
HDLBits练习-有限状态机FSM
taccc的博客
10-30 416
Exams/ece241 2013 q4-水位问题 关于状态机，我一般会问自己几个问题： 1、输入是什么？ 2、现态是什么？ 3、次态是什么？ 4、转换条件是什么？ 5、输出是什么？ 在这个问题中，输入是3个传感器，现态和次态是4个水位状态（water level），转换条件是3个传感器的值是什么情况，输出是水阀的开关状态。其中水阀分两类，一类是固定水阀（nominal flow），一类是辅助水阀（supplemental flow）。 module top_module ( .
通用有限状态机（FSM: Finite-state machine）自动代码生成器
12-27
通用有限状态机（FSM: Finite-state machine）自动代码生成器. 可以根据配置文件，自动生成状态机代码（C++）。配置文件中只需要定义状态，跃迁条件。然后完善每个状态的动作即可。省去开发过程中手写状态机的麻烦。...
StateMachine:用Kotlin编写的有限状态机（FSM）-DFA
05-11
有限状态机 用Kotlin编写的优雅的有限状态机（DFA）。 我在添加了基本代码，还添加了强类型支持以及其他内容。 添加到您的依赖项 将其添加到存储库末尾的root build.gradle中： allprojects { repositories { ...
testSta状态机对应代码.rar_FSM_Finite-state machine_有限状态机_状态机
09-20
有限状态机又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。它反映从系统开始到现在时刻的输入变化，转移指示状态变更，并且用必须满足来确使转移发生的条件来...
StateS:绘制和模拟有限状态机（FSM）-开源
04-29
绘制有限状态机（FSM）的简单工具。 支持FSM构建，模拟并导出到VHDL和PDF。 *在Linux下执行StateS需要Qt（Windows版本为独立版本）*开发的早期阶段！ StateS并不是完整的，甚至暂时还没有用！ 但是，欢迎您对其进行...
fsm_keil_version3_keil有限状态机_fsm打开_8051实现状态机_
10-04
有限状态机（FSM）是一种数学模型，它具有有限数量的状态，这些状态之间通过事件（或输入）相互转换。在8051实现中，这些状态通常由变量表示，而状态转换则通过条件语句（如if-else）或switch-case结构来实现。 "_...
Lemmings3
m0_58080224的博客
03-14 119
module top_module( input clk, input areset, // Freshly brainwashed Lemmings walk left. input bump_left, input bump_right, input ground, input dig, output walk_left, output walk_right, output aaah, output digging .
HDLBits(十 一)学习笔记——有限状态机（FSM onehot - Fsm serialdp）
H19981118的博客
04-22 2414
1、采用独热码的方式进行编写 2、掌握三段式状态机 3、学会将多个输出进行拆分，拆分成多个always块，能更清楚的分析每个输出信号
HDLBits练习——Fsm1
tanxinxin512的博客
10-14 209
HDLBits练习
C++实现有限状态机FSM详解
"有限状态机_FSM_的实现" 有限状态机（Finite State Machine, FSM）是一种计算模型，常用于描述和设计系统的行为。它由一组有限的状态、初始状态、最终状态以及状态之间的转换规则组成。当系统接收到特定输入时，会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Fighting_FPGA

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值