【牛客网刷题系列 之 Verilog进阶挑战】~ 序列检测专题

最新推荐文章于 2023-04-24 14:47:11 发布
最新推荐文章于 2023-04-24 14:47:11 发布
阅读量1.1k 收藏 24
点赞数
分类专栏： FPGA刷题系列 文章标签： fpga开发 集成测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40549426/article/details/125695846
版权

目录：

0. 前言

对于序列检测的题目，一般可以用两种方法完成：状态机 或者 移位寄存器。

可以参考一下这篇博客，这是我之前写的，现在为了刷题，规整了一下，里边讲解的很清楚了，这里我就不多说了，直接传送门。

1. 题目VL25 输入序列连续的序列检测

1.1 题目描述

请编写一个序列检测模块，检测输入信号a是否满足01110001序列，当信号满足该序列，给出指示信号match。

1.1.1 信号示意图

在这里插入图片描述

1.1.2 波形示意图

在这里插入图片描述

1.1.3 输入描述

clk：系统时钟信号
rst_n：异步复位信号，低电平有效
a：单比特信号，待检测的数据

1.1.4 输出描述

match：当输入信号a满足目标序列，该信号为1，其余时刻该信号为0

1.2 解题思路

该题的状态转移图如下所示：
在这里插入图片描述
其实，这类题写出状态转移图就简单了不少，剩下的就交给状态机，哈哈哈！！！

1.3 代码实现

`timescale 1ns/1ns
module sequence_detect(
	input clk,
	input rst_n,
	input a,
	output reg match
	);

    parameter
        s0 = 8'b0000_0001,
        s1 = 8'b0000_0010,
        s2 = 8'b0000_0100,
        s3 = 8'b0000_1000,
        s4 = 8'b0001_0000,
        s5 = 8'b0010_0000,
        s6 = 8'b0100_0000,
        s7 = 8'b1000_0000;
    reg [7:0] cur_state, nex_state;
    
    // step one
    always @ (posedge clk or negedge rst_n) begin
        if(!rst_n) begin
           cur_state <= 8'd0; 
        end
        else begin
           cur_state <= nex_state; 
        end
    end
    //step two
    always @ (*) begin
        case(cur_state)
            s0 : nex_state = a ? s1 : s0;
            s1 : nex_state = a ? s2 : s0;
            s2 : nex_state = a ? s3 : s0;
            s3 : nex_state = a ? s0 : s4;
            s4 : nex_state = a ? s1 : s5;
            s5 : nex_state = a ? s1 : s6;
            s6 : nex_state = a ? s7 : s0;
            s7 : nex_state = s0;
            default : nex_state = s0;
        endcase
    end
    //step three
    always @ (posedge clk or negedge rst_n) begin
        if(!rst_n) begin
           match <= 1'b0; 
        end
        else begin
           match <=  (cur_state == s7) ? 1'b1 : 1'b0;
        end
    end
//     assign match = (cur_state == s7) ? 1'b1 : 1'b0;
endmodule

1.4 测试文件

待更新。。。

1.5 仿真波形

待更新。。。

2. VL26 含有无关项的序列检测

2.1 题目描述

请编写一个序列检测模块，检测输入信号a是否满足011XXX110序列（长度为9位数据，前三位是011，后三位是110，中间三位不做要求），当信号满足该序列，给出指示信号match。

2.1.1 信号示意图

在这里插入图片描述

2.1.2 波形示意图

在这里插入图片描述

2.1.3 输入描述

clk：系统时钟信号
rst_n：异步复位信号，低电平有效
a：单比特信号，待检测的数据

2.1.4 输出描述

match：当输入信号a满足目标序列，该信号为1，其余时刻该信号为0

2.2 解题思路

该题的状态转移图如下所示：
在这里插入图片描述
这个题相比于上一个题而言，多了几个不定态，那变化的地方就是这几个不定态的状态转移图有些变化，只不过不用再判断这几个不定态的输入，就可以直接确定它的下一个状态了，反而简单了不少。
这个题我给出了两种解法，可以参考一下！

2.3 代码实现

2.3.1 状态机法

`timescale 1ns/1ns
module sequence_detect(
	input clk,
	input rst_n,
	input a,
	output reg match
	);

// ============================状态机法==========================================================
// /*
   parameter
        IDLE = 10'b00_0000_0001,
        s0 = 10'b00_0000_0010,
        s1 = 10'b00_0000_0100,
        s2 = 10'b00_0000_1000,
        s3 = 10'b00_0001_0000,
        s4 = 10'b00_0010_0000,
        s5 = 10'b00_0100_0000,
        s6 = 10'b00_1000_0000,
        s7 = 10'b01_0000_0000,
        s8 = 10'b10_0000_0000;
    reg [9:0] cur_state, nex_state;
    
    // step one
    always @ (posedge clk or negedge rst_n) begin
        if(!rst_n) begin
           cur_state <= IDLE; 
        end
        else begin
           cur_state <= nex_state; 
        end
    end
    //step two
    always @ (*) begin
        case(cur_state)
            IDLE : nex_state = a ? IDLE : s0;
            s0 : nex_state = a ? s1 : s0;
            s1 : nex_state = a ? s2 : s0;
            s2 : nex_state = s3;
            s3 : nex_state = s4;
            s4 : nex_state = s5;
            s5 : nex_state = a ? s6 : s0;
            s6 : nex_state = a ? s7 : s0;
            s7 : nex_state = a ? s0 : s8;
            s8 : nex_state = a ? IDLE : s0;
            default : nex_state = IDLE;
        endcase
    end
    //step three
    always @ (posedge clk or negedge rst_n) begin
        if(!rst_n) begin
           match <= 1'b0; 
        end
        else begin
            match <=  (cur_state == s8 && a == 0) ? 1'b1 : 1'b0;
        end
    end
endmodule

2.3.2 移位寄存器法

`timescale 1ns/1ns
module sequence_detect(
	input clk,
	input rst_n,
	input a,
	output reg match
	);

    
//==================================寄存器法==================================================

    reg [8:0] val;
     
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            val <= 9'b0;
        end else begin
            val <= {val[7:0],a};
        end
    end
     
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            match <= 1'b0;
        end 
        else begin
            casex (val)
                9'b011xxx110 : match <= 1'b1;
                default : match <= 1'b0;
            endcase
        end
    end
endmodule

2.4 测试文件

待更新。。。

2.5 仿真波形

待更新。。。

3. VL27 不重叠序列检测

3.1 题目描述

请编写一个序列检测模块，检测输入信号（a）是否满足011100序列， 要求以每六个输入为一组，不检测重复序列，例如第一位数据不符合，则不考虑后五位。一直到第七位数据即下一组信号的第一位开始检测。当信号满足该序列，给出指示信号match。当不满足时给出指示信号not_match。

3.1.1 信号示意图

在这里插入图片描述

3.1.2 波形示意图

在这里插入图片描述

3.1.3 输入描述

clk：系统时钟信号
rst_n：异步复位信号，低电平有效
a：单比特信号，待检测的数据

3.1.4 输出描述

match：当输入信号a满足目标序列，该信号为1，其余时刻该信号为0
not_match：当输入信号a不满足目标序列，该信号为1，其余时刻该信号为0

3.2 解题思路

该题的状态转移图如下所示：
在这里插入图片描述

这个题必须使用计数器+状态机（寄存器）来实现，因为题目要求从第一位到第六位。只要有一位不符合那只能等到第七位再进行为期6个数的判断了。

这个题我给出了两种解法，可以参考一下！

3.3 代码实现

3.3.1 状态机法

`timescale 1ns/1ns
module sequence_detect(
	input clk,
	input rst_n,
	input data,
	output reg match,
	output reg not_match
	);
    
     /*
        =============================状态机法===================================================
    */

   parameter
        IDLE = 7'b000_0001,
        s0 = 7'b000_0010,
        s1 = 7'b000_0100,
        s2 = 7'b000_1000,
        s3 = 7'b001_0000,
        s4 = 7'b010_0000,
        s5 = 7'b100_0000;

    reg [6:0] cur_state, nex_state;
    reg [2:0] cnt;
    
    //计数器
    always@(posedge clk or negedge rst_n) begin
        if(~rst_n) begin
            cnt <= 3'd0;
        end
        else if(cnt == 3'd5) begin
            cnt <= 3'd0;
        end
        else begin
            cnt <= cnt + 3'd1;
        end
    end
    // step one
    always @ (posedge clk or negedge rst_n) begin
        if(!rst_n) begin
           cur_state <= IDLE; 
        end
        else begin
           cur_state <= nex_state; 
        end
    end
    //step two
    always @ (*) begin
        case(cur_state)
            IDLE : nex_state = data ? IDLE : s0;
            s0 : nex_state = data ? s1 : s0;
            s1 : nex_state = data ? s2 : s0;
            s2 : nex_state = data ? s3 : s0;
            s3 : nex_state = data ? IDLE : s4;
            s4 : nex_state = data ? s1 : s5;
            s5 : nex_state = data ? s1 : s0;
            default : nex_state = IDLE;
        endcase
    end
    //step three
    always @ (posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            match <= 1'b0; 
            not_match <= 1'b0;
        end
        else if(cnt == 3'd5) begin
            if(cur_state == s4 && data == 0) begin
                match <=  1'b1;
                not_match <= 1'b0;
            end
            else begin
                match <=  1'b0;
                not_match <= 1'b1;
            end
        end
        else begin
            match <= 1'b0;
            not_match <= 1'b0;
        end
    end
endmodule

3.3.2 移位寄存器法

`timescale 1ns/1ns
module sequence_detect(
	input clk,
	input rst_n,
	input data,
	output reg match,
	output reg not_match
	);

    /*
        =============================寄存器法===================================================
    */
    reg [2:0] cnt;
    reg [5:0] data_r;
     
    always@(posedge clk or negedge rst_n) begin
        if(~rst_n)
            cnt <= 0;
        else
            cnt <= cnt==5? 0: cnt+1;
    end
     
    always@(posedge clk or negedge rst_n) begin
        if(~rst_n)
            data_r <= 6'b0;
        else
            data_r <= {data_r[4:0], data};
    end
     
    always@(posedge clk or negedge rst_n) begin
        if(~rst_n) begin
            match     <= 1'b0;
            not_match <= 1'b0;
        end
        else begin
            match     <= (cnt==5) && ({data_r[4:0], data}==6'b011100);
            not_match <= (cnt==5) && ({data_r[4:0], data}!=6'b011100);
        end
    end
endmodule

3.4 测试文件

待更新。。。

3.5 仿真波形

待更新。。。

4. VL28 输入序列不连续的序列检测

4.1 题目描述

请编写一个序列检测模块，输入信号端口为data，表示数据有效的指示信号端口为data_valid。当data_valid信号为高时，表示此刻的输入信号data有效，参与序列检测；当data_valid为低时，data无效，抛弃该时刻的输入。当输入序列的有效信号满足0110时，拉高序列匹配信号match。

4.1.1 信号示意图

在这里插入图片描述

4.1.2 波形示意图

在这里插入图片描述

4.1.3 输入描述

clk：系统时钟信号
rst_n：异步复位信号，低电平有效
data：单比特信号，待检测的数据
data_valid：输入信号有效标志，当该信号为1时，表示输入信号有效

4.1.4 输出描述

match：当输入信号data满足目标序列，该信号为1，其余时刻该信号为0

4.2 解题思路

该题的状态转移图如下所示：
在这里插入图片描述

这个题和之前的题目不一样的地方在于，有一个有效位判断数据是否有效，这其实就是在状态转移条件那里加一个判断有效无效就行，有效，那就转移，无效，拉到，就是干！！！

这个题我给出了两种解法，可以参考一下！

4.3 代码实现

4.3.1 状态机法

`timescale 1ns/1ns
module sequence_detect(
	input clk,
	input rst_n,
	input data,
	input data_valid,
	output reg match
	);
// ============================状态机法==========================================================
parameter
        IDLE = 5'b0_0001,
        s0 = 5'b0_0010,
        s1 = 5'b0_0100,
        s2 = 5'b0_1000,
        s3 = 5'b1_0000;

    reg [4:0] cur_state, nex_state;
    
    // step one
    always @ (posedge clk or negedge rst_n) begin
        if(!rst_n) begin
           cur_state <= IDLE; 
        end
        else begin
           cur_state <= nex_state; 
        end
    end
    //step two
    always @ (*) begin
        case(cur_state)
            IDLE : begin
                if(data_valid) begin
                    nex_state = data ? IDLE : s0;
                end
                else begin
                    nex_state = cur_state;
                end
            end
            s0 : begin
                if(data_valid) begin
                    nex_state = data ? s1 : s0;
                end
                else begin
                    nex_state = cur_state;
                end
            end
            s1 : begin
                if(data_valid) begin
                    nex_state = data ? s2 : s0;
                end
                else begin
                    nex_state = cur_state;
                end
            end
            s2 : begin
                if(data_valid) begin
                    nex_state = data ? IDLE : s3;
                end
                else begin
                    nex_state = cur_state;
                end
            end
            s3 : begin
                if(data_valid) begin
                    nex_state = data ? IDLE : s0;
                end
                else begin
                    nex_state = cur_state;
                end
            end
            default : begin
                if(data_valid) begin
                    nex_state = IDLE;
                end
                else begin
                    nex_state = cur_state;
                end
            end
        endcase
    end
    //step three
    always @ (posedge clk or negedge rst_n) begin
        if(!rst_n) begin
           match <= 1'b0; 
        end
        else begin
            match <=  (cur_state == s2 && data == 0) ? 1'b1 : 1'b0;  //这个是米粒型的（次态与输入和现态有关）
        end
    end
endmodule

4.3.2 移位寄存器法

`timescale 1ns/1ns
module sequence_detect(
	input clk,
	input rst_n,
	input data,
	input data_valid,
	output reg match
	);
// ============================寄存器法==========================================================
    reg [3:0] shift_reg;
    
    //shift_reg
    always @ (posedge clk or negedge rst_n) begin
        if(!rst_n) begin
           shift_reg <= 4'd0; 
        end
        else begin
            if(data_valid) begin  //这里很关键！！！
                shift_reg <= {shift_reg[2:0], data}; 
            end
        end
    end
    //compare
    always @ (posedge clk or negedge rst_n) begin
        if(!rst_n) begin
           match <= 1'b0; 
        end
        else begin
            if(data_valid && shift_reg[2:0] == 3'b011 && !data) begin
               match <= 1'b1; 
            end
            else begin
               match <= 1'b0; 
            end
        end
    end
    
endmodule

4.4 测试文件

待更新。。。

4.5 仿真波形

待更新。。。

声明

本人所有系列的文章，仅供学习，不可商用，如有侵权，请告知，立删！！！

本人主要是记录学习过程，以供自己回头复习，再就是提供给后人参考，不喜勿喷！！！

如果觉得对你有用的话，记得收藏+评论！！！

IC二舅
关注
  • 0
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【牛客Verilog快速入门】基础语法代码和仿真代码演示 VL1 四选一多路器
小白蒋-材料转行芯片验证
04-21 1442
作者：小白蒋 7年材料专业转行芯片验证，两年芯片验证工作经验。 目录题目：信号示意图：波形示意图：输入描述：输出描述：解答：设计代码实现：验证平台实现：makefile脚本实现：仿真看波形： 题目： 制作一个四选一的多路选择器，要求输出定义上为线网类型 状态转换： d0 11 d1 10 d2 01 d3 00 信号示意图： 波形示意图： 输入描述： 输入信号 d1,d2,d3,d4 sel 类型 wire 输出描述： 输出信号 mux_out 类型 wire 解答： 设
牛客网-刷题-Verilog入门
zhuliang0912的博客
02-16 901
【代码】牛客网-刷题-Verilog入门。
牛客网Verilog刷题——VL20
qq_42224089的博客
04-24 380
对比上述两个真值表，我们可以对该四选一数据选择器进行连接，将四选一数据选择器的S1连接到A，S0连接到B，D0连接0，D1连接C，D2连接~C，D3连接1。现在有一个现成的四选一数据选择器，示意图如下。请使用此四选一数据选择器和必要的逻辑门实现r如下表达式：L=A∙B+A∙~C+B∙C。根据该四选一数据选择器，我们可以得到该四选一选择器的输出Y=1的真值表，如下。而对于我们要实现的表达式：L=A∙B+A∙~C+B∙C。该四选一选择器的代码如下。
【牛客网刷题系列 之 Verilog快速入门】~ 四选一多路器
qq_40549426的博客
06-27 1126
从今天开始，决定开始新的一个板块，那就是针对牛客网上边的Verilog题目做一个完整的学习，这里有两个目的，其一是记录一下自己的学习过程；其二是为后边学习这方面的同学提供一个参考
牛客网Verilog刷题——VL18
qq_42224089的博客
04-24 205
根据下面的真值表实现74HC138译码器。
verilog+牛客网刷题自己编写代码汇总+时序分析+状态机等+刷题学习
08-10
2 Verilog进阶挑战 01 序列检测 VL25 输入序列连续的序列检测 VL26 含有无关项的序列检测 VL27 不重叠序列检测 VL28 输入序列不连续的序列检测 02 时序逻辑 VL29 信号发生器 VL30 数据串转并电路 .....
20-Verilog HDL序列检测器设计.7z
03-09
Verilog HDL序列检测器设计,Vivado仿真工程
FPGA设计之 使用Moore状态机 设计序列检测器“101001”
02-16
FPGA设计之 使用Moore状态机 设计序列检测器 。该序列检测器将检测序列“101001”，当检测到该序列时，状态机的输出为1。 资源包括 代码和仿真以及状态转移图的Visio原文件。 具体的说明 请参考本人博客 《使用Moore...
detector_moore_verilog_weighwj2_序列检测器_
09-30
基于verilog的序列检测器的设计及测试，并提供了相关学习资料。
test1_fpga、_verilog序列检测_
10-03
利用fpga 实现对10010 序列的检测 利用状态机完成状态的跳转
输入序列不连续的序列检测
weixin_51244896的博客
08-03 259
输入序列不连续的序列检测。请编写一个序列检测模块，输入信号端口为data，表示数据有效的指示信号端口为data_valid。当data_valid信号为高时，表示此刻的输入信号data有效，参与序列检测；当data_valid为低时，data无效，抛弃该时刻的输入。当输入序列的有效信号满足0110时，拉高序列匹配信号match。...
牛客网Verilog快速入门题目收获——四选一多路器（VL1）
H19981118的博客
04-08 896
经过同学解答，状态转换与波形图均正确，但状态转换的书写不太规范，这里以表格的形式，给数据明确的标识，防止出现理解偏差。
【verilog进阶】输入序列连续的序列检测
贫民百万歌星
01-05 322
当检测到第一个信号为true时，继续检测第二个信号……当检测到第n个信号为ture时，继续检测第n+1个信号，直到所有信号检测均为treu输出match为1，方法一：采用状态机来实现。本文采用方法二来实现，用一个always块接收采集的下一个信号加入缓存序列，最先前的信号则移位溢出，移位操作可以采用位拼接和位截取实现。请编写一个序列检测模块，检测输入信号a是否满足01110001序列，当信号满足该序列，给出指示信号match。match：当输入信号a满足目标序列，该信号为1，其余时刻该信号为0。
牛客网刷题VL1 输入序列连续的序列检测
weixin_44072819的博客
04-19 475
描述 请编写一个序列检测模块，检测输入信号a是否满足01110001序列，当信号满足该序列，给出指示信号match。 模块的接口信号图如下： 模块的时序图如下： 请使用Verilog HDL实现以上功能，并编写testbench验证模块的功能 输入描述： clk：系统时钟信号 rst_n：异步复位信号，低电平有效 a：单比特信号，待检测的数据 输出描述： match：当输入信号a满足目标序列，该信号为1，其余时刻该信号为0 看了一下评论，我怎么感觉大家的状态图画错了，还是我画错了？？ 他们为啥都s4：
Verilog序列检测器-两例
OpenFPGA的博客
12-03 2万+
1　　序列检测器在数据通讯，雷达和遥测等领域中用与检测步识别标志。它是一种用来检测一组或多组序列信号的电路。例如检测器收到一组串行码｛1110010｝后，输出标志1，否则，输出0。 　　考查这个例子，每收到一个符合要求的串行码就需要用一个状态进行记忆。串行码长度为7位，需要7个状态；另外，还需要增加一个“未收到一个有效位”的状态，共8个状态；S0~S7，状态标记符的下标表示有几个有效位被读出。
数字IC设计——用Verilog实现序列检测器（有限状态机FSM）
热门推荐
用心记录每天的学习，提升自己，虽然有的很基础但真的很重要！
10-07 3万+
数字IC设计-FPGA——用Verilog实现序列检测器（有限状态机） 序列检测器：有“101”序列输入时输出为1，其他输入情况下，输出为0。画出状态转移图，并用Verilog描述。 “101” 序列检测器 序列检测器在数据通讯，雷达和遥测等领域中用与检测步识别标志。它是一种用来检测一组或多组序列信号的电路。例如检测器收到一组串行码｛1110010｝后，输出标志1，否则，输出0。 二、“10101” 序列检测器 三、序列检测器设计的思路步骤
verilog 实现序列检测
weixin_44413306的博客
06-21 1384
使用verilog编写一个序列检测模块，可以实现固定序列的检测
（7）字符串序列检测(主代码+testbench)
qq_40178878的博客
08-12 915
（1）主代码 `timescale 1ns / 1ns //状态机之序列检测 welcom module FSM( Clk, //时钟 Rst_n, //复位 Dv, //数据开始有效 Din, //数据输入 ...
牛客网刷题verilog
最新发布
08-24
- *1* *2* [【牛客网刷题系列 之 Verilog快速入门】~ 优先编码器电路①](https://blog.csdn.net/qq_40549426/article/details/125557914)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值