西南交大EDA实验——Sequence Detector

已于 2024-05-16 18:43:59 修改
阅读量630 收藏 3
点赞数 7
文章标签： fpga开发
于 2023-04-15 22:48:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jacksaj/article/details/130176591
版权
本文介绍了西南交大EDA实验中的SequenceDetector设计，该设计能检测四种一致性数据序列：增量、递减和稳定。通过Mealy型状态机实现，根据MODE输入切换不同检测模式，并在满足条件时输出标志信号OUT_VALID和DATA_OUT。文章详细阐述了状态编码、状态转换逻辑以及输出信号的处理方法，并提供了testbench的编写思路。
摘要由CSDN通过智能技术生成

西南交大EDA实验——Sequence Detector

一、实验内容及要求

1. 目的

在这里插入图片描述

设计一种能够根据配置模式检测四个一致性数据并输出标志的序列检测器。

·支持增量模式：可以检测到四个一致性递增的数据

·支持减少模式：可以检测到四个一致性递减的数据

·支持稳定模式：可以检测到四个一致性相同的数据

2. 说明

在这里插入图片描述
在这里插入图片描述

·文件名：SEQUENCE.v

·模块名：SEQ_DETECTOR

·I/O端口：

RST_B：位宽为1bit的输入。系统异步复位，低电平有效。

SYSCLK：位宽为1bit的输入。系统时钟

IN_VALID：位宽为1bit的输入。高电平有效。输入信号MODE和DATA_IN只有在IN_VALID = 1的时候有效。当IN_VALID = 0时，MODE和DATA_IN应被忽略，并且状态应与IN_VALID = 1时相同。

MODE：位宽为2bit的输入。检测模式，这个信号决定了检测模式。00：增量检测模式，其中四个一致性增长数据(如1，2，3，4或15，0，1，2)可以置OUT_VALID为逻辑1。01：递减检测模式，其中4个一致性递减数据(如5，4，3，2或0，15，14，13)可以置OUT_VALID为逻辑1。10：稳定检测模式，其中4个相同的数据(如0，0，0，0)可以置OUT_VALID为逻辑1。11：与IN_VALID=1作用相同。

DATA_IN：位宽为4bit的输入。输入数据，该信号只有在IN_VALID = 1并且MODE != 2’b11时有效。

OUT_VALID：位宽为1bit的输出。输出有效位，高电平有效。当根据检测模式接收到四个一致性数据是，该信号才生效。

DATA_OUT：位宽为4bit的输出。当OUT_VALID生效时，DATA_OUT应等于DATA_IN，其他情况都等于0。

3. 要求

在这里插入图片描述

4. 波形

在这里插入图片描述在这里插入图片描述

二、内容讲解及代码编写

首先，先把顶层模块的输入和输出写上。

module	SEQ_DETECTOR
(
    input   wire            SYSCLK      ,
    input   wire            RST_B       ,
    input   wire            IN_VALID    ,
    input   wire    [1:0]   MODE        , 
    input   wire    [3:0]   DATA_IN     ,
    
    output  reg             OUT_VALID   ,
    output  reg    [3:0]    DATA_OUT  
);
    
 
endmodule

我们需要用到Mealy型状态机，先将需要的状态想好。初始状态S0，以增量模式（MODE=2’b00）为例，假设检测到第一个数0进入状态INCREMEN_STATE1，下一个检测到1进入状态INCREMENT_STATE2，再检测到2进入状态INCREMENT_STATE3，此时已经检测到3个增量，这时如果再检测到3，就要输出OUT_VALID = 1和DATA_OUT，同时保持状态在INCREMENT_STATE3，因为1，2，3又是三个连续递增的序列，下一个数据如果是4，也可以构成一个递增的序列1,2,3,4。类似，我们还需要减少模式的状态DECREMENT_STATE1 、DECREMENT_STATE2 、DECREMENT_STATE3和稳定模式的状态EQUAL_STATE1、EQUAL_STATE2、 EQUAL_STATE3。因此我们共需要10个状态，对这10个状态进行编码：

parameter	S0      			= 4'd0  ,  
			INCREMEN_STATE1   	= 4'd1  ,   
			INCREMEN_STATE2   	= 4'd2  ,   
			INCREMEN_STATE3   	= 4'd3  ,   
			DECREMENT_STATE1   	= 4'd4  ,   
			DECREMENT_STATE2   	= 4'd5  ,   
			DECREMENT_STATE3   	= 4'd6  ,   
			EQUAL_STATE1   		= 4'd7  ,   
			EQUAL_STATE2   		= 4'd8  ,   
			EQUAL_STATE3   		= 4'd9  ;

对状态进行编码后，我们就要考虑状态的转换了，状态转换就需要判断输入的序列是递增、递减还是相等的。如何判断呢？因为使用时序逻辑赋值，会使数据慢一个周期，这样可以比较输入的数据了。

reg	[3:0]	data_in_delay;
always@(posedge SYSCLK, negedge RST_B)
    begin
        if(!RST_B)
            data_in_delay <= 4'd0;
        else if(IN_VALID && MODE != 4'd3)//IN_VALID = 0或MODE = 2'b11时，输入信号是无效的
            data_in_delay <= DATA_IN;
        else
            data_in_delay <= data_in_reg;
    end

考虑完如何判断输入的序列是递增、递减还是相等后，终于到了状态转换的部分了。

在前面，我们已经考虑了增量模式下，状态的转换，另外两个模式类似。但是，我们似乎漏掉了某些特殊的情况，比如说，开始时MODE = 2’b00（增量状态），在状态INCREMENT_STATE2时，MODE发生了改变，这时，下一状态应该什么呢？所以我们现在要考虑半途MODE变化的情况（MODE它叛变了）。继续刚才的例子，假如MODE在状态INCREMENT_STATE2时变成了2’b01，那么这时我们应该检测递减的序列，是不是要回到初始状态S0重新开始呢？不，这个时候，我们已经接受到了数据，我们应该把当前接受到的数据当做递减序列的第一个数，所以我们的状态应该是DECREMENT_STATE1。同理，MODE跳变为2’b00和2’b10对应着INCREMENT_STATE1和EQUAL_STATE1两个状态。所以，状态转换部分，我们应该这样写：

reg	[3:0]	state;
always@(posedge SYSCLK, negedge RST_B)
    begin
        if(!RST_B)
            state <=  S0  ;
        else if(IN_VALID && MODE != 2'b11)
            begin
                case(state)
                S0      :begin
                            if(MODE == 2'b00)
                                state <= INCREMEN_STATE1;
                            else if(MODE == 2'b01)
                                state <= DECREMENT_STATE1;
                            else if(MODE == 2'b10)
                                state <= EQUAL_STATE1;
                            else
                                state <= S0;
                        end
                INCREMEN_STATE1   :begin
                            if(MODE == 2'b00)
                                begin
                                    if(DATA_IN == data_in_delay + 4'd1)
                                        state <= INCREMEN_STATE2;
                                    else
                                        state <= S0;
                                end
                            else if(MODE == 2'b01)
                                state <= DECREMENT_STATE1;
                            else if(MODE == 2'b10)
                                state <= EQUAL_STATE1;
                            else
                                state <= S0;
                        end
                INCREMEN_STATE2   :begin
                            if(MODE == 2'b00)
                                begin
                                    if(DATA_IN == data_in_delay + 4'd1)
                                        state <= INCREMEN_STATE3;
                                    else
                                        state <= S0;
                                end
                            else if(MODE == 2'b01)
                                state <= DECREMENT_STATE1;
                            else if(MODE == 2'b10)
                                state <= EQUAL_STATE1;
                            else
                                state <= S0;
                        end
                INCREMEN_STATE3   :begin
                            if((MODE == 2'b00) && (DATA_IN == data_in_delay + 4'd1))
                                state <= INCREMEN_STATE3;
                            else if(MODE == 2'b01)
                                state <= DECREMENT_STATE1;
                            else if(MODE == 2'b10)
                                state <= EQUAL_STATE1;
                            else
                                state <= S0;
                        end
                DECREMENT_STATE1   :begin
                            if(MODE == 2'b00)
                                state <= INCREMEN_STATE1;
                            else if(MODE == 2'b01)
                                begin
                                    if(DATA_IN + 4'd1 == data_in_delay)
                                        state <= DECREMENT_STATE2;
                                    else
                                        state <= S0;
                                end
                            else if(MODE == 2'b10)
                                state <= EQUAL_STATE1;
                            else
                                state <= S0;
                        end
                DECREMENT_STATE2   :begin
                            if(MODE == 2'b00)
                                state <= INCREMEN_STATE1;
                            else if(MODE == 2'b01)
                                begin
                                    if(DATA_IN + 4'd1 == data_in_delay)
                                        state <= DECREMENT_STATE3;
                                    else
                                        state <= S0;
                                end
                            else if(MODE == 2'b10)
                                state <= EQUAL_STATE1;
                            else
                                state <= S0;
                        end
                DECREMENT_STATE3   :begin
                            if(MODE == 2'b00)
                                state <= INCREMEN_STATE1;
                            else if((DATA_IN + 1'b1 == data_in_delay) && (MODE == 2'b01))
                                state <= DECREMENT_STATE3;
                            else if(MODE == 2'b10)
                                state <= EQUAL_STATE1;
                            else
                                state <= S0;
                        end
                EQUAL_STATE1   :begin
                            if(MODE == 2'b00)
                                state <= INCREMEN_STATE1;
                            else if(MODE == 2'b01)
                                state <= DECREMENT_STATE1;
                            else if(MODE == 2'b10)
                                begin
                                    if(DATA_IN == data_in_delay)
                                        state <= EQUAL_STATE2;
                                    else
                                        state <= S0;
                                end
                            else
                                state <= S0;
                        end
                EQUAL_STATE2   :begin
                            if(MODE == 2'b00)
                                state <= INCREMEN_STATE1;
                            else if(MODE == 2'b01)
                                state <= DECREMENT_STATE1;
                            else if(MODE == 2'b10)
                                begin
                                    if(DATA_IN == data_in_delay)
                                        state <= EQUAL_STATE3;
                                    else
                                        state <= S0;
                                end
                            else
                                state <= S0;
                        end
                EQUAL_STATE3   :begin
                            if(MODE == 2'b00)
                                state <= INCREMEN_STATE1;
                            else if(MODE == 2'b01)
                                state <= DECREMENT_STATE1;
                            else if((DATA_IN == data_in_delay) && (MODE == 2'b10))
                                state <= EQUAL_STATE3;
                            else
                                state <= S0;
                        end
                default :state <= S0;  
                endcase
            end
        else
            state <=  state;
    end

在这里，我们没有用到常用的state和next_state来进行状态的转移。因为作者最开始就是用的这种方法，结果仿真的时候发现，我们理想的情况下，state和next_state是每个周期变化一次，但是因为使用的是时序逻辑，而在时序逻辑了，state <= next_state, next_state是在state的前提进行转换。第一个周期内state = S0，next_state = S0,第二个周期内，next_state会在state = S0的条件下进行变换，next_state = INCREMENT_STATE1，第三个周期内，next_state还是会在state = S0的状态下进行变换，所以next_state = INCREMENT_STATE1,而state会在next_state = INCREMENT_STATE1的条件下变换，因为我们使用的时序逻辑。第四个周期内，next_state在state = INCREMENT_STATE1的条件下变换，next_state = INCREMENT_STATE2，state在next_state = INCREMENT_STATE1的条件下变换。这样，我们发现，stage和next_state从S0到INCREMENT_STATE1，从INCREMENT_STATE1到INCREMENT_STATE2都需要两个周期，这与我们想要的情况不符，所以我们不采用state和next_state这种方法进行状态转移。大家也可以自己去试一试这种情况。

OK！我们已经完成了最难的部分了，接下来就是输出信号了！

首先是OUT_VALID

在状态INCREMENT_STATE3时，如果再检测到一个递增的数，就输出OUT_VALID为高电平，其他检测模式类似。

always@(posedge SYSCLK, negedge RST_B)
    begin
        if(!RST_B)
            OUT_VALID <= 1'b0;
        else if(!IN_VALID || MODE == 2'b11)//IN_VALID = 0或者MODE = 2'b11时，无效
            OUT_VALID <= 1'b0;
        else
        begin
            case(state)
            INCREMEN_STATE3   :begin
                        if((DATA_IN == data_in_delay + 1'b1) && (MODE == 2'b00))
                            OUT_VALID <= 1'b1;
                        else
                            OUT_VALID <= 1'b0;
                     end   
            DECREMENT_STATE3   :begin
                        if((DATA_IN + 1'b1 == data_in_delay) && (MODE == 2'b01))
                            OUT_VALID <= 1'b1;
                        else
                            OUT_VALID <= 1'b0;
                     end 
            EQUAL_STATE3   :begin
                        if((DATA_IN == data_in_delay) && (MODE == 2'b10))
                            OUT_VALID <= 1'b1;
                        else
                            OUT_VALID <= 1'b0;
                     end 
            default :       OUT_VALID <= 1'b0;
            endcase
        end
    end

最后是DATA_OUT了

当OUT_VALID生效时，DATA_OUT应等于DATA_IN，其他情况都等于0，因此DATA_OUT的逻辑与OUT_VALID相同

always@(posedge SYSCLK, negedge RST_B)
    begin
        if(!RST_B)
            DATA_OUT <= 1'b0;
        else if(!IN_VALID || MODE == 2'b11)//IN_VALID = 0或者MODE = 2'b11时，无效
            DATA_OUT <= 1'b0;
        else
            begin
                case(state)
                    INCREMEN_STATE3   :begin
                                if((DATA_IN == data_in_delay + 1'b1) && (MODE == 2'b00))
                                    DATA_OUT <= DATA_IN;
                                else
                                    DATA_OUT <= 1'b0;
                             end   
                    DECREMENT_STATE3   :begin
                                if((DATA_IN + 1'b1 == data_in_delay) && (MODE == 2'b01))
                                    DATA_OUT <= DATA_IN;
                                else
                                    DATA_OUT <= 1'b0;
                             end 
                    EQUAL_STATE3   :begin
                                if((DATA_IN == data_in_delay) && (MODE == 2'b10))
                                    DATA_OUT <= DATA_IN;
                                else
                                    DATA_OUT <= 1'b0;
                             end 
                    default :       DATA_OUT <= 1'b0;
                endcase
            end
    end

这样，我们的RTL代码就写完了，编译没有报错后就可以写testbench了。

也可以看一下生成的状态机。
在这里插入图片描述

三、testbench

​ 按照波形图编写就行

`timescale 1ns/1ns

module tb();

reg             RST_B       ;
reg             SYSCLK      ;
reg             IN_VALID    ;
reg     [1:0]   MODE        ;
reg     [3:0]   DATA_IN     ;

wire            OUT_VALID   ;
wire    [3:0]   DATA_OUT    ;

initial
    begin
        RST_B       <= 1'b0;
        SYSCLK      <= 1'b1;
        IN_VALID    <= 1'b0;
        MODE        <= 2'd0;
        DATA_IN     <= 4'd0;
        #200
        RST_B       <= 1'b1;
        #20 DATA_IN     <= 4'd1;
        #20 DATA_IN     <= 4'd2;
        #20 DATA_IN     <= 4'd3;
        #20 DATA_IN     <= 4'd4;
        #20 DATA_IN     <= 4'd5;
        #20 IN_VALID    <= 1'b1;
            DATA_IN     <= 4'd6;
        #20 DATA_IN     <= 4'd7;
        #20 DATA_IN     <= 4'd8;
        #20 DATA_IN     <= 4'd9;
        #20 DATA_IN     <= 4'd9;
        #20 IN_VALID    <= 1'b0;
        #20 IN_VALID    <= 1'b1;
            MODE        <= 2'd1;
            DATA_IN     <= 4'd6;
        #20 DATA_IN     <= 4'd5;
        #20 DATA_IN     <= 4'd4;
        #20 DATA_IN     <= 4'd3;
        #20 DATA_IN     <= 4'd0;
        #20 IN_VALID    <= 1'b0;
        #20 IN_VALID    <= 1'b1;    
            MODE        <= 2'd2;
            DATA_IN     <= 4'd11;
        #80 DATA_IN     <= 4'd0;
        #20 IN_VALID    <= 1'b0;
        #20 IN_VALID    <= 1'b1;
            MODE        <= 2'd0;
            DATA_IN     <= 4'd4;
        #20 DATA_IN     <= 4'd5;
        #20 DATA_IN     <= 4'd6;
        #20 MODE        <= 2'd1;
            DATA_IN     <= 4'd7;
        #20 DATA_IN     <= 4'd6;
        #20 DATA_IN     <= 4'd5;
        #20 DATA_IN     <= 4'd4;
        #20 MODE        <= 2'd0;
            DATA_IN     <= 4'd5;
        #20 DATA_IN     <= 4'd6;
        #20 DATA_IN     <= 4'd7;
        #20 DATA_IN     <= 4'd8;
        #20 MODE        <= 2'd2;
        #80 IN_VALID    <= 1'b0;
            MODE        <= 2'b0;
        #80 DATA_IN     <= 4'd0;
        #20 IN_VALID    <= 1'b1;
        #20 IN_VALID    <= 1'b0;
            DATA_IN     <= 4'd1;
        #20 IN_VALID    <= 1'b1;  
        #20 DATA_IN     <= 4'd2;
            IN_VALID    <= 1'b0;
        #20 DATA_IN     <= 4'd3;    
        #20 DATA_IN     <= 4'd2;
            IN_VALID    <= 1'b1;
        #20 IN_VALID    <= 1'b0;
            MODE        <= 2'd2;
        #20 DATA_IN     <= 4'd3;
            MODE        <= 2'd1;
        #20 IN_VALID    <= 1'b1;   
            MODE        <= 2'd0;
        #20 IN_VALID    <= 1'b0;    
            DATA_IN     <= 4'd1;
            MODE        <= 2'd1;
        #20 MODE        <= 2'd2;
            DATA_IN     <= 4'd2;           
        #20 IN_VALID    <= 1'b1;
            MODE        <= 2'd0;
            DATA_IN     <= 4'd4; 
        #20 MODE        <= 2'd2;
            DATA_IN     <= 4'd0; 
        #20 MODE        <= 2'd0;   
        #20 MODE        <= 2'd3;
            DATA_IN     <= 4'd1;    
        #20 MODE        <= 2'd0;               
        #20 MODE        <= 2'd3;   
            DATA_IN     <= 4'd2;
        #20 DATA_IN     <= 4'd3;               
        #20 MODE        <= 2'd0;   
            DATA_IN     <= 4'd2;        
        #20 MODE        <= 2'd3;
        #20 DATA_IN     <= 4'd3;
        #20 MODE        <= 2'd0;
        #20 DATA_IN     <= 4'd1;
        
    end

always#10 SYSCLK <= ~SYSCLK;


SEQ_DETECTOR    SEQ_DETECTOR_inst
(
    .RST_B       (RST_B),
    .SYSCLK      (SYSCLK),
    .IN_VALID    (IN_VALID),
    .MODE        (MODE), 
    .DATA_IN     (DATA_IN),

    .OUT_VALID   (OUT_VALID),
    .DATA_OUT    (DATA_OUT)
);



endmodule

任务完成！

欢迎在评论区留言，感谢你的支持！！！

堂钰
关注
  • 7
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
UVM——sequence & item
weixin_42482170的博客
03-23 1188
此处sequence泛指uvm_sequence_item类，item泛指uvm_sequence_item类。 sequence用来实现激励生成和场景控制；item实现对激励所需要的具体数据和控制要求。 sequence item介绍 item基于uvm_object类，具备UVM核心基类所必要的数据操作方法，如copy()，clone()，compare()，record()等。通常将它们划分为以下类： - 控制类。如总线协议上的读写类型、数据长度、传送模式等。 - 负载类。一般指数据总线上的数据包。
UVM——sequence和item的挂载
weixin_42482170的博客
03-29 1408
sequence和sequencer sequence需要挂载到sequencer上方能正常工作，如果有多个sequence同时挂载到一个sequencer时，还需要进行仲裁。以下会对挂载常用的宏和方法进行介绍 sequence宏 sequence的发送和嵌套主要依靠start()和’uvm_do //sequence和item发送实例 class bus_trans extends uvm_sequence_item; rand int data; `uvm_object_utils_begin(bu
EDA实验 序列检测器的设计
06-22
用VHDL语言设计一个序列检测器，其设计电路框图如图9-1所示，状态转换图如图9-2所示，状态转换功能表如表9-3所示，顶层电路原理图如图9-4。要求当检测器连续收到一组串行码（1110010）后，输出为1，其他情况输出为0。其仿真时序波形如图9-5所示。
EDA（Quartus II）——序列检测器设计
楠潼的博客
02-26 1万+
引言： 有限状态机及其设计技术是实用数字系统设计中的重要组成部分，也是实现高效率、高可靠和高速控制逻辑系统的重要途径。 广义而论，只要是涉及触发器的电路，无论电路大小，都能归结为状态机。因此，对于数字系统设计工程师，面对的只要是时序电路设计，状态机的概念则是必须贯穿于整个设计始终的最基本的设计思想和设计方法。 基于现代数字系统设计技术的状态机的HDL表述形态和表述风格具有一定的典型性和规律化。只要把握了这些固定的语句表达部分，就能根据实际需要写出各种不同风格和面向不同实用目的的Verilog状态机了.
【EDA】有限状态机的设计与序列检测器的设计
怪&的个人博客
04-27 3795
一、有限状态机 其是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。 其是时序电路设计中经常采用的一种方式，尤其适用于设计数字系统的控制模块。用Verilog的case、if-else等语句能很好地描述基于状态机的设计。 有限状态自动机（FSM “finite state machine” 或者FSA “finite state automaton” ）是为研究有限内存的计算过程和某些语言类而抽象出的一种计算模型。 有限状态自动机拥有有限数量的状态，每个状态可以迁移到零个或多个状态，输入字串决
西南交大EDA课内实验——TIMER
Jacksaj的博客
03-24 563
西安交大EDA课程，吴新春老师课内实验——TIMER
EDA技术：序列检测器
04-08
1、 设计一个序列检测器，检测序列为“11101000”，检测到后，给出一个时钟周期的正脉冲。要求采用Moore状态机，使用HDL描述，使用ModelSim进行仿真。 2、 设计测试用序列发生器观察波形。
fsm.rar_FSM_sequence detector
09-14
标题 "fsm.rar_FSM_sequence detector" 涉及的核心知识点是使用有限状态机（FSM）在VHDL中实现一个序列检测器。VHDL是一种硬件描述语言，广泛用于数字逻辑系统的建模和设计，包括FPGA和ASIC等硬件平台。下面将详细...
UVM——sequence、sequencer、driver概述
weixin_42482170的博客
03-22 3680
sequence、sequencer、driver关系 三者的关系如上图所示： - sequence产生目标数量的sequence item，并通过随机化使每一个sequence item对象的数据内容不同 - sequence item经过sequencer流向driver - driver将每一个流入的item（req）进行数据解析，按照与DUT的接口协议写入，形成有效激励 - 如有需要，driver解析完一个item后，会将最后的状态信息写回item，再返回给sequencer（rsp），最终抵达s
HBase原理——要弄懂的sequenceId
01-27
当我们讨论HBase的`sequenceId`时，我们实际上是在探讨如何在HBase的内存组件Memstore与持久化的HLog之间建立关联，以解决数据的一致性问题和故障恢复。 **为什么要使用sequenceId？** 1. **数据一致性**：当...
seqdet_sequencedetector_
09-29
检测码流序列10010
eda序列检测器的设计
12-24
eda序列检测器的设计
基于EDA的用状态机实现序列检测器的设计
06-02
、实验目的：用状态机实现序列检测器的设计，并对其进行仿真和硬件测试。 2、实验仪器：PC机，操作系统为Windows2000/xp, Quartus II 5.1 设计平台，GW48系列SOPE/EDA实验开发系统。 3、实验原理：序列检测器可用于检测一组或多组由二进制码组成的脉冲序列信号，当序列检测器连续收到一组串行二进制码后，如果这组码与检测器中预先设置的码相同，则输出1，否则输出0。由于这种检测的关键在于正确码的收到必须是连续的，这就要求检测器必须记住前一次的正确码及正确序列，直到在连续的检测中所收到的每一位码都与预置数的对应码相同。在检测过程中，任何一位不相等都将回到初始状态重新开始检测。例6-27描述的电路完成对序列数"11100101"的。当这一串序列数高位在前（左移）串行进入检测器后，若此数与预置的密码数相同，则输出“A”，否则仍然输出“B”。
# eda 序列检测器 vhdl
weixin_49616551的博客
09-02 973
序列检测器vhdl
2. sequence detector UVM test
ICJJ的博客
04-20 384
一个简单的验证实例 DUT 序列检测器： 当检测到输入为“1011”时，输出为1； Test plan 使用UVM进行验证； 包含以下几个模块： sequence：产生随机串行输入； driver：接收item并且通过virtual interface输入到DUT中； monitor：捕捉输入与输出的值，创建一个packet并发送到scoreboard； scoreboard：根据输入输出的值检查DUT的正确性； 输入的随机数应至少包含以下序列： 011011011010 101011100 11
EDA实验 1011序列检测器
Hu_peilin的博客
11-16 1815
刚做完的EDA实验，存个档 moore型是同步复位，mealy型是异步复位 1，Moore型源代码： module select1011(x,clk,reset, y ); input x,clk,reset; output reg y; reg [2:0] currentstate; reg [2:0] nextstate; parameter s0=3'b000; parameter s1=3'b001; parameter s2=3'b010; parameter s3=3'b1
EDA技术实用教程 | 复习十二 | 序列检测器
m0_46607832的博客
06-22 2679
序列检测器的设计 序列检测器可用于检测一组或多组由二进制码组成的脉冲序列信号，当序列检测器连续收到一组串行二进制码后，如果这组码与检测器中预先设置的码相同，则输出1，否则输出0。由于这种检测的关键在于正确码的收到必须是连续的，这就要求检测器必须记住前一次的正确码及正确序列，直到在连续的检测中所收到的每一位码都与预置数的对应码相同。在检测过程中，任何一位不相等都将回到初始状态重新开始检测。 以检测6位序列数“110100”为例，介绍序列检测器的设计。 根据序列检测器原理，可以得出序列检测器的状态转换图如下。
EDA实验汇总
热门推荐
多学习
01-31 1万+
EDA实验汇总 实验1_简单组合电路的设计 2选1 module mux21a(a, b, s, y); input a, b, s; output y; assign y = s ? a : b; endmodule 思考题 1-1、用 Verilog 设计一个 3 选 1 多路选择器，并在软件上进行仿真，得出仿真波形。 // 3选1 // 多了一个 2 位的标志位，可以取4种情况 module mux31a(a, b, c, flag, y); input a, b, c; in
序列检测器的设计VHDL代码Quartus仿真
最新发布
xiakunpei123的博客
01-22 1273
代码功能： 用VHDL语言编写一个序列检测器，该序列检测器用于检测一组由二进制码组成的脉冲序列信号，当序列检测器连续收到这组串行二进制码后与检测器中预先设置的码（11100101）相同，则输出1，否则输出0。由于这种检测的关键在于正确码的收到必须是连续的，在检测过程中，任何一位不相等都将导致回到初始状态重新开始检测。 端口信息为： clk:时钟输入端；din:待检测的数据输入端;clr:清零端 dout:数据输出端，输出’1’表示接收到了正确序列，输出’0’表示没接收到正确序列。 设计具体要求：
HBase原理：解析sequenceId的关键作用
"HBase原理——要弄懂的sequenceId" HBase是一个分布式列式存储系统，它的设计目标是处理大规模数据。在HBase的数据写入过程中，sequenceId扮演着至关重要的角色，它解决了HBase中数据的一致性和恢复问题。sequence...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

堂钰

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值