HDLBits学习笔记：Sequential Logic - Finite State Machine

最新推荐文章于 2023-10-24 00:15:00 发布
最新推荐文章于 2023-10-24 00:15:00 发布
阅读量113 收藏
点赞数 1
分类专栏： veilog学习难点总结归纳 文章标签： verilog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acmgotoac/article/details/115700284
版权
本文展示了多个使用Verilog实现的状态机（FSM）模块，包括同步和异步复位，不同输入条件下的状态转换，以及组合逻辑和时序逻辑的应用。每个模块详细说明了状态变量、输入和输出的处理方式，以及如何避免竞争冒险。
摘要由CSDN通过智能技术生成

119. Fsm1

尽量用写时序电路，避免竞争冒险

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

    parameter A=0, B=1; 
    reg state, next_state;
    always@(posedge clk or posedge areset)
        begin
            if(areset) next_state = 1;
            else 
                begin
                    case (state)
                        A : 
                            begin
                                if(in == 0) next_state = B;
                                else next_state = A;
                            end
                        default :
                            begin
                                if(in == 0) next_state = A;
                                else next_state = B;
                            end
                    endcase
                end
            state = next_state;
                        case(state)
                            A : out = 0;
                            default : out = 1;
                        endcase
        end
endmodule

120. Fsm1s

// 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
    parameter A = 0, B = 1;
    reg present_state, next_state;

    always @(posedge clk) begin
        if (reset) begin  
            next_state = B;
        end else begin
            case (present_state)
                A : 
                    begin
                        if(in == 0) next_state = B;
                        else next_state = A;
                    end
                B:
                    begin
                        if(in == 0) next_state = A;
                        else next_state = B;
                    end
            endcase
        end
            // State flip-flops
            present_state = next_state;   

            case (present_state)
                A : out = 0;
                B : out = 1;
            endcase
    end

endmodule

121. Fsm2

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

    parameter OFF=0, ON=1; 
    reg state, next_state;
    always@(posedge clk or posedge areset)
        begin
            if(areset) next_state = OFF;
            else
                begin
                    case (state)
                        OFF :
                            begin
                                if(j == 0) next_state = OFF;
                                else next_state = ON;
                            end
                    	default :
                            begin
                                if(k == 0) next_state = ON;
                                else next_state = OFF;
                            end
                    endcase
                end
		state = next_state;
                        case (state)
                            OFF : out = 0;
                            default : out = 1;
                        endcase
        end
endmodule

113. Fsm2s

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

    parameter OFF=0, ON=1; 
    reg state, next_state;
    always@(posedge clk)
        begin
            if(reset) next_state = OFF;
            else
                begin
                    case (state)
                        OFF :
                            begin
                                if(j == 0) next_state = OFF;
                                else next_state = ON;
                            end
                    	default :
                            begin
                                if(k == 0) next_state = ON;
                                else next_state = OFF;
                            end
                    endcase
                end
		state = next_state;
                        case (state)
                            OFF : out = 0;
                            default : out = 1;
                        endcase
        end
endmodule

114. Fsm3comb

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

    parameter A=0, B=1, C=2, D=3;
    always@(*)
        begin
            case(state)
                A :
                    begin
                        if(in == 0) next_state = A;
                        else next_state = B;
                        out = 0;
                    end
                B :
                    begin
                        if(in == 0) next_state = C;
                        else next_state = B;
                        out = 0;
                    end
                C :
                    begin
                        if(in == 0) next_state = A;
                        else next_state = D;
                        out = 0;
                    end
                default :
                    begin
                        if(in == 0) next_state = C;
                        else next_state = B;
                        out = 1;
                    end
            endcase
        end
endmodule

115. Fsm3onehot

画状态转移图，四个状态的值决定了他们可以由state[A/B/C/D]来表示。

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

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

endmodule

116.Fsm3

module top_module(
    input clk,
    input in,
    input areset,
    output reg out); //
    parameter A = 0, B = 1, C = 2, D = 3;
    reg [1:0] state, next_state;
    always@(posedge clk or posedge areset)
        begin
            if(areset)  next_state = A;
            else
                begin
                    case (state)
                        A:
                                if(in) next_state = B;
                                else next_state = A;
                        B:
                                if(in) next_state = B;
                                else next_state = C;
                        C:
                            	if(in) next_state = D;
                                else next_state = A;
                        default:
                                if(in) next_state = B;
                                else next_state = C;
                    endcase
                end
            state = next_state;
            case (state)
                D : out = 1;
                default : out = 0;
            endcase
        end

endmodule

117. Fsm3s

module top_module(
    input clk,
    input in,
    input reset,
    output reg out); //
    parameter A = 0, B = 1, C = 2, D = 3;
    reg [1:0] state, next_state;
    always@(posedge clk)
        begin
            if(reset)  next_state = A;
            else
                begin
                    case (state)
                        A:
                                if(in) next_state = B;
                                else next_state = A;
                        B:
                                if(in) next_state = B;
                                else next_state = C;
                        C:
                            	if(in) next_state = D;
                                else next_state = A;
                        default:
                                if(in) next_state = B;
                                else next_state = C;
                    endcase
                end
            state = next_state;
            case (state)
                D : out = 1;
                default : out = 0;
            endcase
        end

endmodule

118.

acmgotoac
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
TF2.0深度学习实战（三）：搭建LeNet-5卷积神经网络
不积跬步，无以至千里！
03-15 4212
史上最易深度学习实战教程！
有限状态机Finite State Machine详细介绍
11-26
有限状态机（Finite State Machine）是一种时序机，它源自于人们将一个复杂的问题分割成多个简单的部分来处理的思想。状态机通过时钟驱动下的有多个状态，以及状态之间的跳转规则来实现复杂的逻辑，一旦当前的状态确定，也就明确了相关的输入输出。 有限状态机主要分为两个类型：第一类，如果输出只和当前状态有关而和输入无关，称之为Moore状态机；第二类，输出不仅和当前状态有关也和输入有关，称之为Melay型状态机。本节将主要介绍这两类状态机、状态编码以及使用VHDL和Verilog语言描述的设计范例。
HDLBits刷题-Sequential Logic
weixin_44525166的博客
07-14 721
HDLbits刷题
HDLBits 系列（7）——Sequential Logic（Counters、Shift Registers、More Circuits）
Bronceyang的博客
09-09 3583
3.2 Sequential Logic 3.2.2 Counters 1.Four-bit binary counter module top_module ( input clk, input reset, // Synchronous active-high reset output reg [3:0] q); always @(posedge clk)begin if(reset)begin ...
HDLBits 系列（6）——Sequential Logic（Latches and Flip-Flops）
Bronceyang的博客
09-08 1774
目录 3.2 Sequential Logic 3.2.1 Latches and Flip-Flops 1.D flip-flop 2.D flip-flops 3.DFF with reset 4.DFF with reset value 5.DFF with asynchronous reset 6.DFF with byte enable 7.D Latch 8.DFF 9.DFF 10.DFF+gate 11.Mux and DFF 12.M...
HDLBits学习笔记：Sequential Logic
acmgotoac的博客
04-08 419
99. Four-bit binary counter 没什么说的 module top_module ( input clk, input reset, // Synchronous active-high reset output [3:0] q); initial q = 4'b0; always @(posedge clk) begin if(reset) q <= 4'h0; e
Circuits--Sequential Logic--Finite State Machines--Fsm3s
weixin_43668420的博客
05-10 116
网址：https://hdlbits.01xz.net/wiki/Fsm3s module top_module( input clk, input in, input reset, output out); // parameter A=0, B=1, C=2, D=3; reg [1:0] state ; reg [1:0] next_state ; always@(posedge clk )
Zookeeper学习笔记：Zookeeper--分布式框架
MoTui的博客
10-25 3732
Zookeeper学习笔记：Zookeeper–分布式框架标签（空格分隔）： Zookeeper一、什么是Zookeeper Zookeeper 分布式服务框架是 Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：同步配置管理、选举、分布式锁、分组和命名、分布式应用配置项的管理等。本文将从使用者角度详细介绍 Zookeeper 的安装和配置文
Input 0 of layer dense is incompatible with the layer: expected axis -1 of input shape to have value
weixin_45139997的博客
11-26 6785
ValueError: Input 0 of layer dense is incompatible with the layer: expected axis -1 of input shape to have value 784 but received input with shape [None, 28]
高光谱图像分类--HybridSN: Exploring 3-D–2-DCNN Feature Hierarchy for Hyperspectral Image Classification
AshesOfTimeeee的博客
01-04 2909
《HybridSN: Exploring 3-D–2-DCNN Feature Hierarchy for Hyperspectral Image Classification》 S. K. Roy, G. Krishna, S. R. Dubey, B. B. Chaudhuri HybridSN: Exploring 3-D–2-D CNN Feature Hierarchy for Hyperspectral Image Classification, IEEE GRSL 2020 这篇论文构建了一个
运输层:有限状态机(finite state machine FSM)
u011409389的专栏
12-21 1736
有限状态机(finite state machine  FSM) 无论是提供无连接的服务还是面向连接的服务,,一个运输层协议的行为都可以很好地用一个有限状态机来表示.运输层的发送方和接收方都可以被看做是一个具有有限状态的机器.有限状态机总是处于某一种状态中,直到有一件事情发生.对每个时间的响应有两种 :  (1)定义要执行的动作列表(可能为空),并决定下一个状态(可能与当前
[HDLBits做题]Sequential Logic --- Latches and Flip-Flops
weixin_39001610的博客
10-17 150
判断是否有边沿变化，可以采用通过一个寄存器储存前一个状态，然后通过对比当前状态来判断是否存在边沿变化，获取上升沿的状态，方式是采用与来比较当前状态和上一个状态，保证当前状态应该为1，上一个状态为0，得到的结果则是发生上升沿的情况。可以分别拆成两个边沿触发器，然后将两个边沿触发器的结果分别作为另一个边沿触发器的上一个输出状态，对比前后两个输出状态，发生变化则输出1，这里可以用异或关系来表示。你熟悉的触发器是在时钟的上升沿触发的，或者是在时钟的下降沿触发的。注：Qold是D触发器在上升沿到来之前的输出。
【HDLBits习题 2】Circuit - Sequential Logic（2）Counters
ZEROZibER的博客
05-18 117
【HDLBits习题 2】Circuit - Sequential Logic（2）Counters
[HDLBits做题]Sequential Logic --- Shift Registers
weixin_39001610的博客
10-21 92
将触发器的输出标记为Q[7:0]。伽罗瓦LFSR是其中一种特定情况，它的tap（抽头）位置的比特与输出比特进行异或以产生下一个值，而没有抽头位置的比特则参与正常的移位。按照题目意思，首先要构造一个8位移位寄存器，最低位Q[0]输出回到最前端D触发器的输入，包含有enable使能端控制。这个问题中，你将设计一个8x1存储器的电路，其中写入存储器是通过移入来完成的，而读取时“随机访问”，类似于典型的RAM。算数右移的时候，空位不像逻辑右移一样补零，而是补填原数据的最高位（符号位），即正数补0、负数补1。
[HDLBits做题]Sequential Logic --- Counters
weixin_39001610的博客
10-20 89
围绕count4模块构造1-12的计数器，首先考虑三个内部信号，c_enable使能信号，外侧使能则内部count4也使能，所以直接可以将enable与c_enable相连；根据时序图可以看出来该计数器在上升沿计数加一，计数变零有两种情况，一是计数到15后，下一计数归零(此处的归零可以利用进位溢出，因此保持累加即可，但是如果计数范围不是2。按照题目建议设计一个一位十进制计数器bcd4，类似上一题的使用方式，借助前一个计数器输出结果作为下一个计数器的使能端信号，从而实现进位效果。
HDLBits学习（五）Circuits--Sequential Logic(时序逻辑)-Latched and Fli-Flops
m876224398的博客
06-07 539
锁存器相比触发器会消耗更多的资源，所以综合器会在推断出锁存器时产生提醒，防止开发者在不想使用锁存器时，因为代码风格等原因误产生了锁存器。假设你想为这个电路实现分层的Verilog代码，使用其中有触发器和多路复用器的子模块的三个实例。同 D触发器相比，这个元件没有 clk 端口，取而代之的是 ena 端口，所以这是一个锁存器。锁存器的特征在于，相较于 D触发器的触发事件发生于。考虑如下所示的n位移位寄存器电路：为该电路的一级编写一个名为top_module的Verilog模块，包括触发器和多路复用器。
【HDLBits 刷题 6】Circuits（2）Sequential Logic---Latches and Filp Flops
记录学习历程
08-07 4037
这部分的内容比较简单，主要就是学习了创建触发器和锁存器，以及在实际设计中常用的边沿检测。
[HDLBits做题]Sequential Logic ---More Circuits
最新发布
weixin_39001610的博客
10-24 70
在每个时钟周期，每个单元的下一个状态是由左右两个邻居的异或决定的。下表表达了这个规则更详细的内容，其中下一个状态的值是它本身和左右两个邻居值的函数。在此电路中，创建一个512单元的系统q[511:0]，并在每个时钟周期前进一个步长。在此电路中，创建一个512单元的系统q[511:0]，并在每个时钟周期前进一个步长。在每个时钟周期，每个单元的状态会发生改变。下表表达了这个规则更详细的内容，其中下一个状态的值是它本身和左右两个邻居值的函数。这个游戏是一个二位网格上进行的，每个单元格内为1（存活）或0（死亡）。
HDLBits练习——Fsm3comb
tanxinxin512的博客
10-14 262
HDLBits练习
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值