FPGA学习状态机实现序列检测

最新推荐文章于 2023-10-15 17:45:46 发布
最新推荐文章于 2023-10-15 17:45:46 发布
阅读量286 收藏 1
点赞数
文章标签： fpga开发 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51152795/article/details/131188486
版权

状态机实现序列检测

设计目标：检测输入序列10010并标志

状态转移图

状态机

代码

序列检测

module FSM (
    input wire clk,
    input wire rst_n,
    input wire data_in,
    output reg find_out
);

reg [5:0]state; 
parameter   
    IDLE = 6'b000001,
    S0 = 6'b000010,
    S1 = 6'b000100,
    S2 = 6'b001000,
    S3 = 6'b010000,
    S4 = 6'b100000; 

// //一段式 状态转换和输出
// always @(posedge clk or negedge rst_n) begin
//     if (~rst_n) begin
//        state <= IDLE;
//        find_out <= 1'b0; 
//     end
//     else case (state)
//         IDLE:begin
//             find_out <= 1'b0;
//             if (~rst_n) begin
//                 state <= IDLE;
//             end
//             else if (data_in == 1'b0) begin
//                 state <= IDLE;
//             end
//             else begin
//                 state <= S0;
//             end
//         end
//         S0:begin
//             find_out <= 1'b0;
//             if (~rst_n) begin
//                 state <= IDLE;
//             end
//             else if (data_in == 1'b0) begin
//                 state <= S1;
//             end
//             else begin
//                 state <= S0;
//             end
//         end
//         S1:begin
//             find_out <= 1'b0;
//             if (~rst_n) begin
//                 state <= IDLE;
//             end
//             else if (data_in == 1'b0) begin
//                 state <= S2;
//             end
//             else begin
//                 state <= S0;
//             end
//         end
//         S2:begin
//             find_out <= 1'b0;
//             if (~rst_n) begin
//                 state <= IDLE;
//             end
//             else if (data_in == 1'b0) begin
//                 state <= IDLE;
//             end
//             else begin
//                 state <= S3;
//             end
//         end
//         S3:begin
//             find_out <= 1'b0;
//             if (~rst_n) begin
//                 state <= IDLE;
//             end
//             else if (data_in == 1'b0) begin
//                 state <= S4;
//             end
//             else begin
//                 state <= S0;
//             end
//         end
//         S4:begin
//             find_out <= 1'b1;
//             if (~rst_n) begin
//                 state <= IDLE;
//             end
//             else if (data_in == 1'b0) begin
//                 state <= S2;
//             end
//             else begin
//                 state <= S0;
//             end
//         end
//     endcase

// end


// //二段式 
// //状态转化
// always @(posedge clk or negedge rst_n) begin
//     if (~rst_n) begin
//        state <= IDLE; 
//     end
//     else case (state)
//         IDLE:begin
//             if(~rst_n)begin
//                 state <= IDLE;
//             end 
//             else if (data_in == 1'b0) begin
//                 state <= IDLE;
//             end
//             else begin
//                 state <= S0;
//             end
//         end
//         S0:begin
//            if(~rst_n)begin
//                 state <= IDLE;
//             end 
//             else if (data_in == 1'b0) begin
//                 state <= S1;
//             end
//             else begin
//                 state <= S0;
//             end
//         end
//         S1:begin
//            if(~rst_n)begin
//                 state <= IDLE;
//             end 
//             else if (data_in == 1'b0) begin
//                 state <= S2;
//             end
//             else begin
//                 state <= S0;
//             end
//         end
//         S2:begin
//             if(~rst_n)begin
//                 state <= IDLE;
//             end 
//             else if (data_in == 1'b0) begin
//                 state <= IDLE;
//             end
//             else begin
//                 state <= S3;
//             end
//         end
//         S3:begin
//             if(~rst_n)begin
//                 state <= IDLE;
//             end 
//             else if (data_in == 1'b0) begin
//                 state <= S4;
//             end
//             else begin
//                 state <= S0;
//             end
//         end
//         S4:begin
//             if(~rst_n)begin
//                 state <= IDLE;
//             end 
//             else if (data_in == 1'b0) begin
//                 state <= S2;
//             end
//             else begin
//                 state <= S0;
//             end
//         end
//     endcase
// end
// //结果输出
// always @(posedge clk or negedge rst_n) begin
//     if (~rst_n) begin
//        find_out <= 1'b0; 
//     end
//     else case (state)
//         IDLE:find_out <= 1'b0;
            
//         S0:find_out <= 1'b0;
            
//         S1:find_out <= 1'b0;
           
//         S2:find_out <= 1'b0;
           
//         S3:find_out <= 1'b0;
           
//         S4:find_out <= 1'b1;
        
//         default:find_out <= 1'b0;
//     endcase
// end

//三段式
reg [5:0]current_state;
reg [5:0]next_state;

//第一段时序逻辑
always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        current_state <= IDLE;
    end
    else begin
        current_state <= next_state;
    end
end

//组合逻辑表示状态转移
always @(*) begin
    case (current_state)
        IDLE:begin
            if (~rst_n) begin
                next_state = IDLE;
            end
            else if (data_in == 1'b0) begin
                next_state = IDLE;
            end
            else begin
                next_state = S0;
            end
        end
        S0:begin
            if (~rst_n) begin
                next_state <= IDLE;
            end
            else if (data_in == 1'b0) begin
                next_state <= S1;
            end
            else begin
                next_state <= S0;
            end
        end
        S1:begin
            if (~rst_n) begin
                next_state <= IDLE;
            end
            else if (data_in == 1'b0) begin
                next_state <= S2;
            end
            else begin
                next_state <= S0;
            end
        end
        S2:begin
            if (~rst_n) begin
                next_state <= IDLE;
            end
            else if (data_in == 1'b0) begin
                next_state <= IDLE;
            end
            else begin
                next_state <= S3;
            end
        end
        S3:begin
            if (~rst_n) begin
                next_state <= IDLE;
            end
            else if (data_in == 1'b0) begin
                next_state <= S4;
            end
            else begin
                next_state <= S0;
            end
        end
        S4:begin
            if (~rst_n) begin
                next_state <= IDLE;
            end
            else if (data_in == 1'b0) begin
                next_state <= S2;
            end
            else begin
                next_state <= S0;
            end
        end
        // IDLE: next_state = data_in ? S0 : IDLE;
        // S0: next_state = data_in ? S0 : S1;
        // S1: next_state = data_in ? S0 : S2;
        // S2: next_state = data_in ? S3 : IDLE;
        // S3: next_state = data_in ? S0 : S4;
        // S4: next_state = data_in ? S0 : S2;
        // default: next_state = IDLE;
    endcase
end
//结果输出
always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
       find_out <= 1'b0; 
    end
    else case (current_state)
        IDLE:find_out <= 1'b0;
            
        S0:find_out <= 1'b0;
            
        S1:find_out <= 1'b0;
           
        S2:find_out <= 1'b0;
           
        S3:find_out <= 1'b0;
           
        S4:find_out <= 1'b1;
        
        default:find_out <= 1'b0;
    endcase
end
endmodule

tb文件

`timescale 1ns/1ps

module FSM_tb ();
    
reg clk;
reg rst_n;
reg data_in;
wire find_out;


initial begin
    clk = 1'b0;
    rst_n = 1'b0;
    data_in = 1'b0;
    #10
    rst_n = 1'b1;
end

always #10 clk = ~clk;

always #20 data_in = {$random} % 2; 

FSM FSM_1(
    .clk(clk),
    .rst_n(rst_n),
    .data_in(data_in),
    .find_out(find_out)
);

endmodule

仿真结果

仿真

与雨渔遇鱼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
使用状态机完成序列检测器
04-03
使用状态机，对输入序列进行序列检测，当输入序列正确时，输出为1，其它情况输出为0。prj_quartus是quartus文件，prj_modelsim是modelsim仿真文件，src是程序源码包含testbench
Verilog状态机序列检测器
11-09
怎样用状态机实现1101,11001,111110001等特征序列的检测。
10010序列检测器
记录和分享学习和工作过程中的个人总结
05-12 3552
10010序列检测器 重复检测输入，当检测到输入端顺序输入10010序列时，输出为1。 1.使用同步状态机 1.状态转移图 2.Verilog 实现 module detect_10010( input clk, input rst_n, input in_a, output reg detect); parameter S0 = 3'b000, S1 = 3'b001, S2 = 3'b010, S3 = 3'
序列检测（FSM状态机）
Lethe_01的博客
05-17 4307
FSM有限状态机
Verilog-实现基于状态机的序列检测--一段式状态机、二段式状态机、三段式状态机
Anzg256的博客
04-12 3181
将时序逻辑和组合逻辑划分开来，时序逻辑进行当前状态和下一状态的切换，组合逻辑实现输入、输出以及状态的判断，这种写法相对容易维护，不过组合逻辑输出容易出现毛刺等问题。代码易维护，时序逻辑的输出解决了二段式写法中组合逻辑的毛刺问题，但是三段式消耗的资源相对多一点，并且三段式从输入到输出比一段式和二段式会延时一个时钟周期。将所有的逻辑（输入、输出、状态）在一个always块里进行描述，这种写法看起来简单，但对于复杂的状态会容易出错，并且在大型项目中这些代码是不利于维护的。的工作，这就要用到状态机的思想。
【 FPGA 】序列检测器 11010 (mealy状态机，moore状态机)
小张爱学习哦的博客
08-26 5350
状态机是硬件电路设计的常用的描述工具，也是电路设计的重要思想。很早之前我就知道mealy状态机和moore状态机，但是对两者的差别不是非常的清楚，最近在学习系列检测器的设计时对这两种状态机和一段式、三段式状态机有了更深刻的了解，在这里分享自己的见解给大家。有什么理解不准确的地方也希望大家指正。
Verilog 代码编写 状态机-序列检测
qq_46132759的博客
01-19 1771
题目： 有一种特殊的串行通信系统，数据以包的形式传输，数据的包头为 01111110， 然后为数据内容，然后 01111110 结尾，现在需要编写程序，完成数据包头插入和接收，试画出两种情况下FSM 转态转移图。 分析： 按照题意，数据接收开始对包头数据进行检测，当检测到 01111110 序列时， 将开启传输信号，正式接收数据内容，然后边传输边继续检测序列，当再次出现 01111110 序列时，停止传输，接收停止。 采用有限状态机的方法来进行编写，需要先明确各状态和状态...
简单的状态机设计——序列检测器
weixin_57520386的博客
12-15 4855
对串行输入的数据进行检测，检测“10010”。设X为数字码流输入，Z为检出标记输出，高电平表示“发现指定序列”，低电平表示“没有发现指定序列”。考虑码流为“1100100100001001001…对串行数据进行检测，检测到连续4个1 、5个1、6个1Z输出为高电平，连续7个或者7个以以上报错，即ERRO输出高电平。序列检测器是时序数字电路中非常常见的设计之一。它的逻辑功能是将一个指定的序列从数字码流中识别出来。
FPGA_状态机_序列检测器
红茶绿茶和奶茶的博客
06-24 4292
“硬件设计很讲究并行设计思想，虽然用Verilog描述的电路大都是并行实现的，但是对于实际的工程应用，往往需要让硬件来实现一些具有一定顺序的工作，这就要用到状态机思想。什么是状态机呢？简单的说，就是通过不同的状态迁移来完成一些特定的顺序逻辑。硬件的并行性决定了用Verilog描述的硬件实现（臂如不同的always语句）都是并行执行的，那么如果希望分多个时间完成一个任务，怎么办？也许可以用多个使能信号来衔接多个不同的模块，但是这样做多少显得繁琐。状态机的提出会大大简化这一工作。” ———— 特权同学
序列模三检测器（状态机法设计原理|verilog代码|Testbench|仿真结果）
Loudrs的博客
04-29 3472
对于模三检测器有三种余数分别是0、1、2。当序列每次新增1bit数据时，其实相当于逻辑左移运算，就是在原来的数据上×2,再根据新增的1bit数据与之相加确定下一个状态的余数。例如，即100到1001的过程（即十进制数4到9的过程）：当前数据模三余数为1，在数据右端新增1bit数据1，最后会发现下一状态的余数变为0！
IC验证学习笔记（手撕代码）-4序列检测器（状态机）
weixin_46403587的博客
04-27 233
要每个周期给seq随机化一个值。
FPGA实例04——序列检测器设计及测试
qq_38502780的博客
10-17 4956
序列检测器：将一个指定的序列从数字码流中识别出来。 下面设计一个序列检测器，将码流中的“10010”序列检测出来： ①三个输入，clk，rst_n，x，其中x是以为的输入，多个x的数据构成码流 ②输出z，在检测到完整的10010序列时，z拉高 ③由此我们需要用一个状态机来记录检测的状态，具体如图所示： ④状态变化规律 复位后处于IDLE状态 在IDLE状态时，当x为1，进入A状态，否则保持IDLE状态 在A状态时，当x为0，进入B状态，否则保持A状态
状态机实现序列检测
04-01
通过状态机实现序列检测，对10010进行检测，可实现重叠序列的检测，整程序用verilog实现
序列1101检测FPGA verilog实现
11-26
序列1101检测FPGA verilog实现，带测试激励。
FPGA实现序列检测器两种实现方式（状态机+移位寄存器）
10-29
FPGA实现序列检测器两种实现方式（状态机+移位寄存器）（绝对有用）
基于FPGA的序列检测器（一段式状态机为例）
最新发布
weixin_47143639的博客
10-15 92
假设有一段数据流，要求从数据流中识别出Hello,若识别成功，输出一个高电平，控制led灯发生反转。状态2：检测e,若为e，则跳转到状态3，否则跳转到状态1，判断第一个字母是否为H。状态3：检测l,若为l,则跳转到状态4，否则跳转到状态1，判断第一个字母是否为H。状态4：检测l,若为l,则跳转到状态5，否则跳转到状态1，判断第一个字母是否为H。状态5：检测o,若为o,则控制LED小灯打开，并回到状态1继续检测。状态1:检测到H,跳转到状态2，判断是否为e。为了便于理解，以一段式状态机为例。
[FPGA入门笔记]（九）：序列检测实验，Moore和Mealy状态机对比
贾小瑞的博客
11-23 2584
简介 今天购买了AXLINX AX7020的开发板，从今天开始每一个例程都要做文档记录，为自己加油。 本实验，基于ALINX AX7020开发板，芯片为xc7z020clg400-2。开发板输入时钟为50MHz。 序列检测器设计 序列检测器可用于检测一组或多组由二进制码组成的脉冲序列信号，当序列检测器连续收到一组串行二进制码后，如果这组码与检测器中预先设置的码相同，则输出1，否则输出0。 **关键步骤：**正确码的接收必须是连续的，要求检测器必须记住前一次的正确码及正确序列，直到在连续的检测中所收到的每一位
FPGA 状态机-序列检测器verilog
weixin_30739595的博客
08-26 1368
实现功能：检测出串行输入数据4位Data二进制序列0101，当检测到该序列的时候，out=1，否则out=0 （1）给出状态编码，画出状态图 （2）门电路实现 （3）verilog实现 首先规定Q3Q2Q1为刚输入的三位数，接下来要输入的数是A,Z为输入A以后的状态机的输出结果，则可以画出状态转换图如下： 然后根据状态图，我们可以得到状态表： 从而推导出激励方程，根据卡...
FPGA序列检测
weixin_43841387的博客
06-29 559
关于FPGA序列检测问题，主要采取状态机和序列缓存两种办法，通常序列缓存法的实现更为简单，尤其是在目标序列较长的环境下。针对不同的具体要求，在匹配判断时进行针对性调整即可。
利用fpga状态机进行1010序列检测;
05-01
利用FPGA状态机进行1010序列检测，可以通过实现一个有限状态自动机来实现。 有限状态自动机是一种状态机，它的状态数量有限，且只能在有限个输入下从一个状态转移到另一个状态。在进行1010序列检测时，我们需要实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值