Finite State Machines

已于 2023-08-28 15:08:29 修改
阅读量58 收藏
点赞数
文章标签： fpga开发
于 2023-08-21 21:56:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62994144/article/details/132417572
版权
文章详细介绍了Fsm的设计，包括使用参数化的状态机模块，结合组合逻辑和时序逻辑实现状态转换，以及异步复位功能。讨论了不同类型的Fsm结构，如Moore和Mealy模型，以及多输入信号处理的方法。
摘要由CSDN通过智能技术生成

Fsm1

分析参考 

法一：

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;

    always @(*) begin    // This is a combinational always block
        // State transition logic
        case(state)
            A:begin next_state=in?A:B; end
            B:begin next_state=in?B:A; end
        endcase
    end

    always @(posedge clk, posedge areset) begin    // This is a sequential always block
        // State flip-flops with asynchronous reset
        if(areset)begin
            state<=B;
        end
        else begin
            state<=next_state;
        end
    end
	
    assign out=state;
    // Output logic
    // assign out = (state == ...);

endmodule

法二：

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

    parameter A=0, B=1; 
    reg state;

    always @(posedge clk, posedge areset) begin    // This is a sequential always block
        // State flip-flops with asynchronous reset
        if(areset)begin
            state<=B;
        end
        else begin
            case(state)
                A:begin state<=in?A:B; end
                B:begin state<=in?B:A; end
            endcase
        end
    end
	
    assign out=state;
    // Output logic
    // assign out = (state == ...);

endmodule

Fsm1s

module top_module(
    input clk,
    input reset,    // Asynchronous reset to state B
    input in,
    output out);//  
 
    parameter A=0, B=1; 
    reg state;
 
    always @(posedge clk) begin    // This is a sequential always block
        // State flip-flops with asynchronous reset
        if(reset)begin
            state<=B;
        end
        else begin
            case(state)
                A:begin state<=in?A:B; end
                B:begin state<=in?B:A; end
            endcase
        end
    end
	
    assign out=state;
    // Output logic
    // assign out = (state == ...);
 
endmodule

Fsm3comb

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

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

    // State transition logic: next_state = f(state, in)
    always@(*)begin
        case(state)
            A:begin next_state=in?B:A; end
            B:begin next_state=in?B:C; end
            C:begin next_state=in?D:A; end
            D:begin next_state=in?B:C; end
        endcase
    end
    
    // Output logic:  out = f(state) for a Moore state machine
    assign out=(state==D)?1'b1:1'b0;

endmodule

Fsm3onehot

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

    parameter A=0, B=1, C=2, 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[B] & in | state[D] & in;
    assign next_state[C] = state[B] & (~in) | state[D] & (~in);
    assign next_state[D] = state[C] & in;

    // Output logic: 
    assign out = state[D];

endmodule

Fsm3

module top_module(
    input clk,
    input in,
    input areset,
    output out); //
    
    parameter A=0,B=1,C=2,D=3;
    
    reg[1:0] state,next_s;

    // State transition logic
    always@(*)begin
        case(state)
            A:begin next_s=in?B:A; end
            B:begin next_s=in?B:C; end
            C:begin next_s=in?D:A; end
            D:begin next_s=in?B:C; end
        endcase
    end

    // State flip-flops with asynchronous reset
    always@(posedge clk or posedge areset)begin
        if(areset)begin
            state<=A;
        end
        else begin
           state<=next_s; 
        end
    end

    // Output logic
    assign out=(state==D)?1:0;

endmodule

Lemmings1

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=0, RIGHT=1;
    reg state, next_state;

    always @(*) begin
        // State transition logic
        case(state)
            LEFT: 
                begin
                    if(bump_left)begin
                        next_state<=RIGHT;
                    end
                    else begin
                        next_state<=LEFT;
                    end
                end
            RIGHT:
                begin
                	if(bump_right)begin
                        next_state<=LEFT;
                    end
                    else begin
                        next_state<=RIGHT;
                    end
                end
        endcase
    end

    always @(posedge clk, posedge areset) begin
        // State flip-flops with asynchronous reset
        if(areset)begin
            state<=LEFT;
        end
        else begin
            state<=next_state;
        end
    end

    // Output logic
    assign walk_left = (state == LEFT);
    assign walk_right = (state == RIGHT);

endmodule

Lemmings2

 以下代码仿真成功

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=0, RIGHT=1, fall_l=2, fall_r=3;
    reg[1:0] state, next_state;//共四个state，要定义位宽；
    reg[2:0] out;//{walk_left, walk_right, aaah}

    always @(*) begin
        // State transition logic
        case(state)
            LEFT: begin next_state = ground ? (bump_left ? RIGHT : LEFT) : fall_l; end
            RIGHT: begin next_state = ground ? (bump_right ? LEFT : RIGHT) : fall_r; end
            fall_l: begin next_state = ground ? LEFT : fall_l; end
            fall_r: begin next_state = ground ? RIGHT : fall_r; end
        endcase
    end
    
    always @(posedge clk or posedge areset) begin
        // State flip-flops with asynchronous reset
        if(areset)begin
            state <= LEFT;
        end
        else begin
            state <= next_state;
        end
    end

    always @(posedge clk or posedge areset) begin
        // State flip-flops with asynchronous reset
        if(areset)begin
            out<=3'b100;
        end
        else begin
            case(next_state)
            	LEFT: begin out <= 3'b100; end //有方向，不叫
            	RIGHT: begin out <= 3'b010; end //有方向，不叫
            	fall_l: begin out <= 3'b001; end //没有方向，叫
            	fall_r: begin out <= 3'b001; end //没有方向，叫
        	endcase
        end
    end

    // Output logic
    assign {walk_left, walk_right, aaah} = out;

endmodule

以下代码仿真失败，时序有问题

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=0, RIGHT=1;
    reg state, next_state;
 
    always @(*) begin
        // State transition logic
        case(state)
            LEFT: 
                begin
                    if(ground==0)begin
                        aaah<=1;
                        next_state<=0;
                    end
                    else begin
                        aaah=0;
                        if(bump_left)begin
                        	next_state<=RIGHT;
                    	end
                    	else begin
                        	next_state<=LEFT;
                    	end
                    end
                end
            RIGHT:
                begin
                    if(ground==0)begin
                        aaah<=1;
                        next_state<=0;
                    end
                    else begin
                        aaah<=0;
                        if(bump_right)begin
                        	next_state<=LEFT;
                    	end
                    	else begin
                        	next_state<=RIGHT;
                    	end
                    end
                end
        endcase
    end
 
    always @(posedge clk, posedge areset) begin
        // State flip-flops with asynchronous reset
        if(areset)begin
            state<=LEFT;
        end
        else begin
            state<=next_state;
        end
    end
 
    // Output logic
    assign walk_left = (state == LEFT && ground);
    assign walk_right = (state == RIGHT && ground);
 
endmodule

Lemmings3

Lemmings3.png

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=0, RIGHT=1, fall_l=2, fall_r=3, dig_l=4, dig_r=5;
    reg[3:0] state, next_state;
    reg[3:0] out;//{walk_left, walk_right, aaah, digging}
    
    always@(*)begin
        case(state)
            LEFT: 
                begin  
                    if(ground && ~dig && bump_left)begin
                        next_state = RIGHT;
                    end
                    if(ground && ~dig && ~bump_left)begin
                        next_state = LEFT;
                    end
                    if(~ground)begin
                        next_state = fall_l;
                    end
                    if(ground && dig)begin
                        next_state = dig_l;
                    end
                end
            RIGHT: 
                begin
                	if(ground && ~dig && bump_right)begin
                        next_state = LEFT;
                    end
                    if(ground && ~dig && ~bump_right)begin
                        next_state = RIGHT;
                    end
                    if(~ground)begin
                        next_state = fall_r;
                    end
                    if(ground && dig)begin
                        next_state = dig_r;
                    end
                end
            fall_l: 
                begin
                    if(~ground)begin
                        next_state = fall_l;
                    end
                    if(ground && ~bump_right)begin
                        next_state = LEFT;
                    end
                end
            fall_r: 
                begin
                	if(~ground)begin
                        next_state = fall_r;
                    end
                    if(ground && ~bump_right)begin
                        next_state = RIGHT;
                    end
                end
            dig_l: 
                begin
                	if(~ground)begin
                        next_state = fall_l;
                    end
                    else begin
                        next_state = dig_l;
                    end
                end
            dig_r: 
                begin
                	if(~ground)begin
                        next_state = fall_r;
                    end
                    else begin
                        next_state = dig_r;
                    end
                end
        endcase
    end
    
    always @(posedge clk or posedge areset) begin
        // State flip-flops with asynchronous reset
        if(areset)begin
            state <= LEFT;
        end
        else begin
            state <= next_state;
        end
    end
    
    //{walk_left, walk_right, aaah, digging}
    always@(posedge clk or posedge areset)begin
        if(areset)begin
            out <= 4'b1000;
        end
        else begin
            case(next_state)
            	LEFT: begin out <= 4'b1000; end
            	RIGHT: begin out <= 4'b0100; end
            	fall_l: begin out <= 4'b0010; end
            	fall_r: begin out <= 4'b0010; end
            	dig_l: begin out <= 4'b0001; end
            	dig_r: begin out <= 4'b0001; end
        	endcase
        end
    end
    
    assign {walk_left, walk_right, aaah, digging} = out;

endmodule

Lemmings4

自己写出来总有不对的地方，参考这篇后终于成功，看来多信号还是分开写比较好。

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=0, RIGHT=1, fall_l=2, fall_r=3, dig_l=4, dig_r=5, splatter=6; 
    reg[3:0] state, next_state;
    reg[4:0] con;//计算20内的落地时间；
    reg timeout;
    
    //状态机
    always@(*) begin
        case(state)
            LEFT: begin next_state = ground ? ( dig ? dig_l : (bump_left ? RIGHT : LEFT) ) : fall_l; end
            RIGHT: begin next_state = ground ? ( dig ? dig_r : (bump_right ? LEFT : RIGHT) ) : fall_r; end
            fall_l: begin next_state = ground ? ( timeout ? splatter : LEFT ) : fall_l; end
            fall_r: begin next_state = ground ? ( timeout ? splatter : RIGHT ) : fall_r; end
            dig_l: begin next_state = ground ? dig_l : fall_l; end
            dig_r: begin next_state = ground ? dig_r : fall_r; end
            splatter: begin next_state = splatter; end
        endcase
    end
    
    //state赋值
    always @(posedge clk or posedge areset) begin
        // State flip-flops with asynchronous reset
        if(areset)begin
            state <= LEFT;
        end
        else begin
            state <= next_state;
        end
    end
    
    //timeout
    always@(posedge clk or posedge areset)begin
        if(areset)begin
            timeout <= 0;
        end
        else if(con == 5'd20)begin
            timeout <= 1;
        end
        else begin
           timeout <= timeout; 
        end
    end
    
    //con
    always@(posedge clk or posedge areset)begin
        if(areset)begin
            con <= 5'd0;
        end
        else if(next_state==fall_l || next_state==fall_r)begin
        	con <= con + 1'b1;
    	end
        else begin
            con <= 5'd0;
        end
    end
    
    assign walk_left = (state == LEFT);
    assign walk_right = (state == RIGHT);
    assign aaah = ((state == fall_l) || (state == fall_r));
    assign digging = ((state == dig_l) || (state == dig_r));        

endmodule

Fsm onehot

Fsmonehot.png

这题按要求只能参考Fsm3onehot 

module top_module(
    input in,
    input [9:0] state,
    output [9:0] next_state,
    output out1,
    output out2);
    
    assign next_state[0] = ~in & (state[0] | state[1] | state[2] | state[3] | state[4] | state[7] | state[8] | state[9] ) ;
    assign next_state[1] = in & (state[0] | state[8] | state[9] ) ;
    assign next_state[2] = in & state[1] ;
    assign next_state[3] = in & state[2] ;
    assign next_state[4] = in & state[3] ;
    assign next_state[5] = in & state[4] ;
    assign next_state[6] = in & state[5] ;
    assign next_state[7] = in & (state[6] | state[7]) ;
    assign next_state[8] = ~in & state[5] ;
    assign next_state[9] = ~in & state[6] ;
    
    assign out1 = state[8] | state[9];
    assign out2 = state[7] | state[9];

endmodule

挽轻柔晚风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
HDLbits笔记-Finite State Machines
小虎哥的博客
04-20 348
这一模块中前面的相对简单，所以没有进行记录。主要注意同步复位还是异步复位即可，具体关于同步复位和异步复位的比较请见之前的博客链接: 同步复位异步复位的比较. Fsm3 题目：实现以下状态的转换。注意异步复位。。。 module top_module( input clk, input in, input areset, output out); // reg [1:0] state,next_state; parameter A = 2'b00;
HDLbits9-Finite State Machines
weixin_41543509的博客
05-02 503
15 Finite State Machines 15.1 Simple FSM 1 (asynchronous reset) module top_module ( input clk, input areset, input in, output out ); parameter A = 1'b0, B = 1'b1; reg current_state,next_state; always @(posedge clk or posedge are
「HDLBits题解」Finite State Machines
KS的博客
01-29 1139
的Verilog代码 以提供参考 各位可同时参考我的代码和官方题解代码 或许会有所收益。本专栏的目的是分享可以通过。
Verilog学习笔记HDLBits——Finite State Machines(1)
bigRr的博客
07-24 665
一、Finite State Machines ## 1.Simple FSM 1(asychronous reset) **Practice**:This is a Moore state machine with two states, one input, and one output. Implement this state machine. Notice that the reset state is B. This exercise is the same as fsm1s, but usin
Verilog HDLBits 第十六期：3.2.6 Finite State Machines（3.2.5.5-3.2.5.9）
weixin_51915958的博客
01-19 687
前言 HDLbits网站如下 Problem sets - HDLBits (01xz.net) 失踪人口回归，这个寒假想把hdlbits刷完！ 从本期开始我们继续HDLbits第三章Circuits的学习，本期的内容是Finite State Machines有限状态机的第二小节（3.2.5.5-3.2.5.9） 3.2.5.5 Simple FSM 1(asynchoronous reset) (Fsm1) 这是一个摩尔状态机，有两种状态，单输入单输出。请实现这个状态机。请注意，复位状态为
HDLbits_Finite State Machines 部分（Fsm serial到Fsm serialdp）
bici_1的博客
04-22 524
代码如下:吭哧吭哧找半天错误在哪里，发给npy看，ta说我的parameter为什么出现了WAIT =2'd4，然后我改成了3'd4，运行结果就对了。还不能直接在脑子里画时序，把各个变量的时序图写写画画一下，留着后面好看，感觉写完这个题才对时序有那么一点点入门的感觉了，开心。代码如下：相比于上一题，这一题只是加了一个移位操作以及数据输出。
Verilog HDLBits 第十五期：3.2.5 Finite State Machines（3.2.5.1-3.2.5.4）
weixin_51915958的博客
01-01 426
前言 HDLbits网站如下 Problem sets - HDLBits (01xz.net) 从本期开始我们继续HDLbits第三章Circuits的学习，本期的内容是3.2.5 Finite State Machines有限状态机的第一小节（3.2.5.1-3.2.5.4） 3.2.5.1 Simple FSM 1(asynchoronous reset) (Fsm1) 这是一个摩尔状态机，有两种状态，单输入单输出。请实现这个状态机。请注意，复位状态为 B。 本练习与fsm1s相似，但是.
HDLbits答案更新系列16（3.2.5 Finite State Machines 3.2.5.20 Sequence recognition等）
小k的博客
05-31 5370
今天更新四道题目，今天的题目难度不高，适合用来巩固。希望能和大家一起努力，共同进步~
HDL-Finite State Machines
toomay_Lee的博客
06-30 75
【代码】HDL-Finite State Machines。
FSMPP - Finite State Machines in C++-开源
04-28
有限状态机（Finite State Machine，FSM）是一种计算模型，常用于处理具有固定数量状态的系统，这些系统根据特定输入或事件从一个状态转换到另一个状态。FSMPP是一个专门针对C++编程语言设计的开源库，它为开发者...
论文研究-Testing of Parallel Parameterized Extended Finite State Machines with Dependence on External Variables.pdf
08-15
当前基于模型的测试研究主要集中在单一组件模型，例如有限状态机（FSM）和扩展有限状态机（EFSM）。然而，在一些协议中，可能存在着具有对其他组件的变量依赖的并行组件。使用单一模型精确地定义此类协议是不可能的...
Verilog基础，原码，反码与补码的概念
FPGA/数字IC/通信算法
09-04 1064
Verilog中的module可以看成一个具有输入输出端口的黑盒子，该黑盒子有输入和输出接口(信号)，通过把输入在盒子中执行某些操作来实现某项功能。(类似于C语言中的函数)图1 模块示意图图1 所示的顶层模块(top_module)结构用Verilog语言可描述为：input a,input b,output outendmodule🔹 模块以module 开始，endmodule结束🔹 top_module 为模块名🔹 input : 为输入端口🔹 output: 为输出端口。
FPGA开发：Verilog数字设计基础
qq_74114817的博客
09-03 2489
IP核，全称知识产权核（Intellectual Property core），在集成电路设计领域中扮演着重要角色。通俗地解释，IP核就是那些已经设计好、验证过，并可以重复使用的电路功能模块或设计模块。它们就像是构建积木一样，可以被设计师们用来快速搭建出复杂的集成电路系统，从而大大缩短设计周期，提高设计效率。软IP固IP（Firm IP Core）和硬IP软IP软IP通常是用硬件描述语言（如VHDL或Verilog）编写的功能描述，它只定义了电路的行为和功能，而不涉及具体的电路实现细节。
FIFO求和实验
m0_66619666的博客
09-04 909
现有一5行4列数据矩阵FIFO求和，对该矩阵数据，N = 5，M = 4，使X = 3进行列求和运算，得到S(3,4)新矩阵，则S(0,0)=D(0,0)+D(1,0)+D(2,0),S(0,1)= D(0,1)+D(1,1)+D(2,1),S(0,2)=D(0,2)+D(1,2)+D(2,2),S(0,3)=SD(0,3)+D(1,3)+D(2,3),S(1,0)=D(1,0)+D(2,0)+D(3,0)...S(2,0)=D(2,0)+D(3,0)+D(4,0)。
LabVIEW FIFO详解
最新发布
bjcyck的博客
09-08 802
在LabVIEW的FPGA开发中，FIFO（先入先出队列）是常用的数据传输机制。通过配置FIFO的属性，工程师可以在FPGA和主机之间，或不同FPGA VIs之间进行高效的数据传输。根据具体需求，FIFO有多种类型与实现方式，包括目标范围内FIFO（Target-Scoped）、DMA FIFO以及点对点流（Peer-to-Peer）。
verilog仿真激励
weixin_51418325的博客
09-04 1272
本章节主要描述verilog激励仿真介绍，并携带仿真结果分析。 主要针对寄存器初始化值，基本所有仿真都会使用到该语句，使用如下： repeat 重复有限次数地执行一段代码，使用如下： 例如重复执行5个时钟周期时钟； always # 重复执行，一般使用在时钟上，例如实现一个100MHz系统时钟，使用如下： forever 重复执行，与always有所不同，使用如下： forever和alw
1分钟 快速掌握 双向信号(inout信号)
mengzaishenqiu的博客
09-04 868
三态门，简单来说，是一种具有三种输出状态的逻辑门电路，即逻辑“0”、逻辑“1”和高阻态（High Impedance，通常用字母“Z”表示）。在正常的逻辑电路中，输出只有“0”和“1”两种状态，但三态门增加了高阻态这一特殊状态，使得电路在某些情况下可以呈现出高阻抗的特性，就好像电路被断开一样。这种特性使得三态门在总线通信、数据选择等场景中有着广泛的应用。
FPGA开发：Verilog基础语法
qq_74114817的博客
09-06 950
标识符（identifier）就是模块名、端口名、信号名等，可以类比为软件语言中各个变量、函数的名称（说白了就是取名字）。，它的值是由驱动它的元件所决定的，且一旦有变化就会立即变化（组合逻辑）。值得注意的是，reg型变量并不对应物理（现实）上的寄存器，而是。Verilog数字进制格式包括二进制（'b）、八进制（'o）、十进制（'d）和十六进制（'h）。变量是一种在程序运行过程中其值可以被改变的量，在Verilog HDL中变量的数据类型有很多种。的值是高阻态的，z的另一种表示方式为"?
有限状态机在软件建模中的实践方法
"Modeling Software with Finite State Machines: A Practical Approach" 是一本由Ferdinand Wagner、Ruedi Schmuki、Thomas Wagner和Peter Wolstenholme合著的专业书籍，主要探讨了如何在软件开发中应用有限状态机...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值