HDL-Finite State Machines

已于 2023-07-02 00:58:11 修改
阅读量90 收藏
点赞数
文章标签： fpga开发
于 2023-06-30 21:52:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/toomay_Lee/article/details/131483418
版权

Simple FSM 1 (a)

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=next_state;
        // State transition logic
    end
    always @(posedge clk, posedge areset) begin
        if(areset)
            begin
                out<=1;
                next_state<=B;
            end
        else
            begin
                case({state,in})
                    2'b10:begin
                        out<=0;
                        next_state<=0;
                    end
                    2'b11:begin
                        out<=1;
                        next_state<=1;
                    end
                    2'b01:begin
                        out<=0;
                        next_state<=0;
                    end
                    2'b00:begin
                        out<=1;
                        next_state<=1;
                    end
                endcase
            end
        // This is a sequential always block
        // State flip-flops with asynchronous reset
    end
    // Output logic
    // assign out = (state == ...);
endmodule

 Simple FSM 1 

// Note the Verilog-1995 module declaration syntax here:
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
	reg A=0,B=1;
    reg present_state, next_state;

    always @(posedge clk) begin
        if (reset) begin 
            present_state<=1;
            out<=1;
            // Fill in reset logic
        end else begin
            case (present_state)
                B:next_state=in?B:A;
                A:next_state=in?A:B;// Fill in state transition logic
            endcase
            // State flip-flops
            present_state = next_state;   
   			 case (present_state)
                    1:out=1;
                    0:out=0;// Fill in output logic
                endcase
        end
    end
endmodule

注意各逻辑块执行顺序，先改变next_state的值，后改变present_state的值，最后改变out的值。 

// Note the Verilog-1995 module declaration syntax here:
module top_module(clk, reset, in, out);
    input clk;
    input reset;    // Synchronous reset to state B
    input in;
    output out;//  
    reg out;

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

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

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

    // Output logic
    // assign out = (state == ...);
    assign out = (state == B);

endmodule

Simple FSM 1 (a)

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

    parameter OFF=0, ON=1; 
    reg state, next_state;

    always @(*) begin
        case(state)
            ON: next_state = k?OFF:ON;
            OFF: next_state = j?ON:OFF;
        endcase// State transition logic
    end

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

    // Output logic
    // assign out = (state == ...);
    assign out = (state==ON);

endmodule

 Simple FSM 2

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

    parameter OFF=0, ON=1; 
    reg state, next_state;

    always @(*) begin
        case(state)
            ON: next_state = k?OFF:ON;
            OFF: next_state = j?ON:OFF;
        endcase
        // State transition logic
    end

    always @(posedge clk) begin
        if(reset)
            state<=OFF;
        else
            state<=next_state;
        // State flip-flops with synchronous reset
    end

    // Output logic
    // assign out = (state == ...);
            assign out = (state==ON);

endmodule

Simple state transitions 3

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:next_state = in? B:A;
                B:next_state = in? B:C;
                C:next_state = in? D:A;
                D:next_state = in? B:C;
            endcase
        end
    // Output logic:  out = f(state) for a Moore state machine
    assign out = (state==D)?1:0;
endmodule

Simple one-hot state transitions 3

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

 Simple FSM 3(a)

module top_module(
    input clk,
    input in,
    input areset,
    output out); //
    
    reg[1:0] A=2'd0,B=2'd1,C=2'd2,D=2'd3;
    reg[1:0] state,next_state;

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

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

    // Output logic
    assign out = (state==D);

endmodule

 Simple FSM 3

module top_module(
    input clk,
    input in,
    input reset,
    output out); //
    
    reg[1:0] A=2'd0,B=2'd1,C=2'd2,D=2'd3;
    reg[1:0] state,next_state;

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

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

    // Output logic
    assign out = (state==D);

endmodule

Lemmings 1

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;
    reg left=0, right=1;

    always @(*) begin
        // State transition logic
        case(state)
            left: next_state = bump_left?right:left;
            right: next_state = bump_right?left:right;
        endcase
    end

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

    // Output logic
    // assign walk_left = (state == ...);
    // assign walk_right = (state == ...);
    assign walk_left = (state == left);
    assign walk_right = (state == right);

endmodule

Lemmings 2

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;
    reg left=0, right=1;
    reg f_ground;

    always @(*) begin
        // State transition logic
        case(state)
            left: next_state = (bump_left&&ground&&f_ground)?right:left;
            right: next_state = (bump_right&&ground&&f_ground)?left:right;
        endcase
    end

    always @(posedge clk, posedge areset) begin
        // State flip-flops with asynchronous reset  
        if(areset)
            begin
            state <= left;
                aaah <= 0;
                walk_left <= 1;
                walk_right <= 0;
            end
        else
            begin
                if(!ground)
                    begin
                    aaah <= 1;
                	walk_left <= 0;
                	walk_right <= 0;
                    f_ground <= 0;
                    end
                else
                    begin
                    aaah <= 0;
            		state = next_state;
                    walk_left <= (state == left);
                	walk_right <= (state == right);
                    f_ground<=1;
                    end
            end
    end
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[1:0] state, next_state;
    parameter left=2'd0;
    parameter right=2'd1;
    parameter ah_left=2'd2;
    parameter ah_right=2'd3;

    always @(*) begin
        // State transition logic
        case(state)
            left: begin
                if(~ground) next_state = ah_left;
                else if(bump_left) next_state = right;
                else next_state = left;
            end
            right: begin
                if(~ground) next_state = ah_right;
                else if(bump_right) next_state = left;
                else next_state = right;
            end
            ah_left: begin
                if(~ground) next_state = ah_left;
                else next_state = left;
            end
            ah_right: begin
                if(~ground) next_state = ah_right;
                else next_state = right;
            end
        endcase
    end

    always @(posedge clk, posedge areset) begin
        // State flip-flops with asynchronous reset  
        if(areset)
            begin
            	state <= left;
            end
        else
			state <= next_state;
    end
    
    assign walk_left=(state==left);
    assign walk_right=(state==right);
    assign aaah=(state==ah_right)||(state==ah_left);
endmodule

toomay_Lee
关注
FSMPP - Finite State Machines in C++-开源
04-28
有限状态机（Finite State Machine，FSM）是一种计算模型，常用于处理具有固定数量状态的系统，这些系统根据特定输入或事件从一个状态转换到另一个状态。FSMPP是一个专门针对C++编程语言设计的开源库，它为开发者...
finite-state-machines
03-14
有限状态机（Finite State Machines, FSM）是一种...通过实践finite-state-machines-master项目中的代码，你可以掌握如何在Java中有效地构建和管理状态机，这对于处理复杂逻辑问题或者需要动态响应输入的系统特别有用。
modeling-software-with-finite-state-machines-a-practical-approach
05-12
在软件工程领域，有限状态机（Finite State Machines, FSM）是一种数学模型，用于描述系统的状态及其响应外部输入时的状态转换过程。《使用有限状态机建模软件：一种实用方法》这本书通过详细讲解如何利用FSM来改进...
Simple-Finite-State-Machine-For-Arduino:Arduino的有限状态机实现
05-01
Arduino的有限状态机 Arduino的有限状态机实现 查看示例以弄清楚它是如何工作的：D如果您对更多文档感兴趣，请告诉我。 给我发送电子邮件或给该项目一颗星 特征： 多状态 输入运行和输出回调 状态独立计时器（RUN_...
relational-finite-state-machine
05-18
关系有限状态机此项目是PoC，用于创建Relational Extendable Menu组件。 即使我们尽可能通用地构建它，它也可以满足我们的需求。 此示例中的关系意味着，祖先及其后代之间的关系必须清楚，才能过滤出后代的子代。...
fpga 同步fifo
LonelyDragons的博客
11-15 129
FIFO（First In First Out，即先入先出），是一种数据缓存器，用来实现数据先入先出。根据 FIFO 工作的时钟域，可以将 FIFO 分为同步 FIFO 和异步 FIFO。同步 FIFO 是指读时钟和写时钟 为同一个时钟，在时钟沿来临时同时发生读写操作，常。异步 FIFO 是指读写时钟不一致，读写时钟是互相独立的，一般用于数据信号跨时钟阈。特性的缓存器，常被用于多比特 数据跨时钟域的转换、读写数据带宽不同步等场合。FIFO 在使用时并不存在像 RAM 那样的读写冲突问题。
基于RK3568+FPGA的1U/2U电力通讯管理机电力网关解决方案
szxinmai的博客
11-15 443
1 x RS232/GPIO/电源, 2 x 4 Pin header, PH=2.54mm 母座 (COMx), 内部连接。②2 x 电口 (RJ45, w/LED, 10/100/1000M自适应)+2 x 100/1000Base光口。● 4 x DO继电器应用 (常开/常闭可选), 4 x DI (NPN/PNP可选), 2KV隔离。①4 x 电口扩展板 (RJ45, w/LED, 10/100/1000M自适应)通信管理机在变电站综合自动化通信系统中的结构图如图。
fpga spi回环
LonelyDragons的博客
11-15 131
在数据传输的过程中,每次接收到的数据必须在下一次数据传输之前被采样,如果之前接收到的数据没有被读取,那么这些已经接收完成的数据将有可能会被丢弃,导致 SPI物理模块最终失效.因此,在程序中一般都会在 SPI传输完数据后,去读取 SPI设备里的数据,即使这。设备好还是从设备),相当于该设备有一个 bit 大小的数据被交换了.一个 Slave 设备要想能够。些数据在我们的程序里是无用的(虽然发送后紧接着的读取是无意义的，但仍然需要从寄存器中读出来)。
fpga异步fifo
LonelyDragons的博客
11-15 32
前面 dout初始值就是0 因为rd_en没有使能。
三分频电路设计
FG的博客
11-15 202
举例，4分频时，1个输出时钟周期内，有4个输入时钟，按照50%的占空比算，输出时钟需要在4/2=2个时钟周期处翻转。这里clk2的变化是根据下降沿来的，数据稳定，建立时间、保持时间都能满足，所以在时钟沿立即就能变化，不会出现打一拍的现象。更具一般性的，4分频计数两个数，2N分频计数2N>>1个数，又由于计数器从0开始，则有：(2N>>1)-1 通式。最简单的，二分频时，直接把输入时钟加到D触发器上，输出端Q取反后，接回输入D端，就可以了。通常情况下，偶数倍分频器，可以借助计数器实现。两种而已，图示如下。
FMC 扩展子卡6 路 422,8 组 LVDS,8 路 GPIO
FPGA_ADDA的博客
11-11 491
FMC 扩展子卡6 路 422,8 组 LVDS,8 路 GPIO
基于ARM+FPGA的电力通信管理机IEC61850规约通信机的实现
szxinmai的博客
11-15 452
而且，如果单个的软核CPU无法满足用户需求，可 以添加多个CPU软核，搭建多核系统，通过多核CPU协同工作，让系统拥有更加 灵活便捷的控制能力和较强的运算处理能力。但是，由于CPU是使用FPGA的通用逻辑资源搭建的，相较使用经过布局布 线优化的硬核处理器来说，软核处理器够运行的最高时钟主频要低一些，而且也 会相应的消耗较多的FPGA逻辑资源以及片上存储器资源，因此SOPC方案仅适 用于那些对于数处理器整体性能要求不高的应用，例如整个系统的初始化配置， 人机交互，多个功能模块间的协调控制等功能。
FPGA 第6讲 简单组合逻辑多路选择器
2201_75297369的博客
11-15 327
时间：2024.11.11-11.14。
FPGA 第7讲 简单组合逻辑译码器
最新发布
2201_75297369的博客
11-15 745
经过验证对比发现两种方法虽然最后实现的功能是一样的，而所得到的 RTL 视图差别较大，但最后的逻辑资源使用却是相同的（时序逻辑中不一定相同），说明综合器进行了适当的优化。if-else 的这种写法是存在优先级的，即第一个 if 中的条件的优先级最高，后面的 if 中的条件的优先级依次递减，好在该 if 中的条件只有一个，也只会产生一种情况，并不会产生优先级的冲突，所以这里优先级的高低关系并不会对最后的功能产生任何影响。
问题An object named ‘ResNetArcFace‘ was already registered in ‘arch‘ registry!
11-15 179
发现是由于ResNetArcFace已经被注册，搜索了下，发下我安装的另外一个库已经包含了。那咋办了，一个是重新开个环境，通过conda创建一个虚拟环境，排除环境依赖，一个是修改源码。在安装 GFPGAN 的时候，一切都顺利，但是执行的时候出现了错误，哦还有一个问题，就是如果basicsr安装不成功可以执行如下命令。回归上面的问题，如果执行出现了如下错误。然后源代码重新安装，执行解决此问题。
(源码)基于JavaWeb的饮品销售管理系统.zip
11-15
# 基于Java Web的饮品销售管理系统 ## 项目简介 本项目是一个基于Java Web的饮品销售管理系统，主要用于学校实训课程的作业。系统涵盖了从用户管理、商品管理、订单管理到购物车管理的全套功能，旨在提供一个完整的在线饮品销售解决方案。 ## 项目的主要特性和功能 ### 用户管理 用户注册与登录支持用户注册新账号和登录系统。 用户信息管理包括用户信息的查询、修改和删除。 用户类型管理区分不同类型的用户（如管理员、普通用户）。 ### 商品管理 商品CRUD操作支持商品的添加、修改、删除和查询。 商品分类管理支持多级商品分类的查询和管理。 商品分页查询支持按页查询商品信息，提高查询效率。 ### 订单管理 订单CRUD操作支持订单的创建、修改、删除和查询。 订单明细管理支持订单明细的添加和管理。 订单状态管理支持订单状态的更新和查询。 ### 购物车管理
BitmapFunc.rar
11-15
BitmapFunc
c++课程设计-产品入库管理操作系统.zip
11-15
c++课程设计-产品入库管理操作系统
c语言火车票订票管理源码.rar
11-15
c语言火车票订票管理源码
finite-state transducer描述
06-04
Finite-state transducer (FST)是一种计算模型，用于将输入序列映射到输出序列。它是有限状态机的一种类型，由状态、转移和输出组成。FST通常由两个有限状态自动机组成：一个输入自动机和一个输出自动机，输入自动机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值