Verilog手撕代码（4）序列检测

最新推荐文章于 2023-11-23 17:41:44 发布
最新推荐文章于 2023-11-23 17:41:44 发布
阅读量522 收藏 7
点赞数
分类专栏： # Verilog手撕代码 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51965113/article/details/130673884
版权

目录


序列检测有两种写法，分别为状态机和移位寄存器，且序列检测也有很多类型，如连续和非连续检测、重叠和非重叠检测、含有无关项检测

连续和不连续序列检测

连续序列检测

检测输入信号a是否满足01110001序列，当信号满足该序列，给出指示信号match

状态机写法

verilog代码：

module sequence_detect(
	input clk,
	input rst_n,
	input a,
	output reg match
);

	parameter IDLE = 9'b0_0000_0001,
					s0 = 9'b0_0000_0010,
					s1 = 9'b0_0000_0100,
					s2 = 9'b0_0000_1000,
					s3 = 9'b0_0001_0000,
					s4 = 9'b0_0010_0000,
					s5 = 9'b0_0100_0000,
					s6 = 9'b0_1000_0000,
					s7 = 9'b1_0000_0000;
	reg [8:0]c_state;
	reg [8:0]n_state;
	
	always@(posedge clk or negedge rst_n)begin
		if(!rst_n)
			c_state <= n_state;
		else
			c_state <= n_state;
	end
	
	always@(*)begin
		case(c_state)
			IDLE:n_state = (a == 1'b0)?s0:IDLE;
			  s0:n_state = (a == 1'b1)?s1:s0;
			  s1:n_state = (a == 1'b1)?s2:s0;
			  s2:n_state = (a == 1'b1)?s3:s0;
			  s3:n_state = (a == 1'b0)?s4:IDLE;
			  s4:n_state = (a == 1'b0)?s5:s1;
			  s5:n_state = (a == 1'b0)?s6:s1;
			  s6:n_state = (a == 1'b1)?s7:s0;
			  s7:n_state = (a == 1'b1)?s2:s0;
			  default:n_state = IDLE;
		endcase
	end
	
	always@(posedge clk or negedge rst_n)begin
		if(!rst_n)
			match <= 1'b0;
		else	
			match <= (n_state == s7)?1'b1:1'b0;
	end	
endmodule

这里采用的是moore型的三段式状态机写法

仿真时，令输a = 01110001110010，由于这里看做是连续且可重叠的检测，因此，仿真结果应该会检测到联两次

关于重叠和非重叠序列检测，将在下面进行讨论

Testbench;

`timescale 1ns/1ns
module sequence_detect_tb();
	reg clk;
	reg rst_n;
	reg a;
	wire match;
	
	
	sequence_detect u0(
		.clk(clk),
		.rst_n(rst_n),
		.a(a),
		.match(match)
	);
	
	always #10 clk = ~clk;
	
	initial begin
		clk = 0;
		rst_n = 0;
		a = 0;
		#10
		rst_n = 1;
		#40 a = 1;
		#20 a = 1;
		#20 a = 1;
		#20 a = 0;	
		#20 a = 0;
		#20 a = 0;
		#20 a = 1;
		#20 a = 1;
		#20 a = 1;
		#20 a = 0;
		#20 a = 0;
		#20 a = 0;
		#20 a = 1;
		#20 a = 0;
		#200
		$stop;		
		
	end
	//状态机查看器
	reg [31:0]state_cur;
	reg [31:0]state_next;
	
	always@(*)begin
		case(u0.c_state)
			9'b0_0000_0001 : state_cur = "IDLE";
			9'b0_0000_0010 : state_cur = "s0";
			9'b0_0000_0100 : state_cur = "s1";
			9'b0_0000_1000 : state_cur = "s2";
			9'b0_0001_0000 : state_cur = "s3";
			9'b0_0010_0000 : state_cur = "s4";
			9'b0_0100_0000 : state_cur = "s5";
			9'b0_1000_0000 : state_cur = "s6";
			9'b1_0000_0000 : state_cur = "s7";
			default:state_cur = "IDLE";
		endcase
	end
	
	always@(*)begin
		case(u0.n_state)
			9'b0_0000_0001 : state_next = "IDLE";
			9'b0_0000_0010 : state_next = "s0";
			9'b0_0000_0100 : state_next = "s1";
			9'b0_0000_1000 : state_next = "s2";
			9'b0_0001_0000 : state_next = "s3";
			9'b0_0010_0000 : state_next = "s4";
			9'b0_0100_0000 : state_next = "s5";
			9'b0_1000_0000 : state_next = "s6";
			9'b1_0000_0000 : state_next = "s7";
			default:state_cur = "IDLE";
		endcase
	end
endmodule

仿真结果：
在这里插入图片描述
结果match拉高两次，在状态机的第三段的输出是基于n_state（次态）的时序逻辑判断的，因此在检测到01110001后的下一个时钟周期match拉高。

移位寄存器写法

verilog代码：

module sequence_detect(
	input clk,
	input rst_n,
	input a,
	output reg match
);
	reg [7:0]a_reg;
	always@(posedge clk or negedge rst_n)begin
		if(!rst_n)
			a_reg <= 8'b0;
		else
			a_reg <= {a_reg[6:0],a};
	end
	
	always@(posedge clk or negedge rst_n)begin
		if(!rst_n)
			match <= 1'b0;
		else
			match <= (a_reg == 8'b0111_0001)?1'b1:1'b0;
	end	
endmodule

Testbench：

`timescale 1ns/1ns
module sequence_detect_tb();
	reg clk;
	reg rst_n;
	reg a;
	wire match;
	
	
	sequence_detect u0(
		.clk(clk),
		.rst_n(rst_n),
		.a(a),
		.match(match)
	);
	
	always #10 clk = ~clk;
	
	initial begin
		clk = 0;
		rst_n = 0;
		a = 0;
		#10
		rst_n = 1;
		#40 a = 1;
		#20 a = 1;
		#20 a = 1;
		#20 a = 0;	
		#20 a = 0;
		#20 a = 0;
		#20 a = 1;
		#20 a = 1;
		#20 a = 1;
		#20 a = 0;
		#20 a = 0;
		#20 a = 0;
		#20 a = 1;
		#20 a = 0;
		#200
		$stop;		
		
	end
endmodule

仿真结果：

在这里插入图片描述
移位寄存器写法与状态机写法仿真结果一致

不连续序列检测

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

状态机写法

verilog代码：

module sequence_detect_1(
	input clk,
	input rst_n,
	input data,
	input data_valid,
	output  reg match
	);

reg [1:0]c_state,n_state;
always@(posedge clk or negedge rst_n)begin
	if(!rst_n)
		c_state <= 2'b00;
	else if(data_valid)
		c_state <= n_state;
	else
		c_state <= c_state; 
end
always@(*)begin
	case(c_state)
		2'b00:
		begin
			if(data_valid)
				n_state  = (data == 1'b0)?2'b01:2'b00;
			else 
				n_state = 2'b00;
		end
		2'b01:
		begin
			if(data_valid)
				n_state  = (data == 1'b1)?2'b10:2'b01;
			else 
				n_state = 2'b01;
		end
		2'b10:
		begin
			if(data_valid)
				n_state  = (data == 1'b1)?2'b11:2'b10;
			else 
				n_state = 2'b10;
		end
		2'b11:
		begin
			if(data_valid)
				n_state  = (data == 1'b0)?2'b00:2'b11;
			else 
				n_state = 2'b11;
		end
		default:n_state = 2'b00;
	endcase
end

always@(posedge clk or negedge rst_n)begin
	if(!rst_n)
		match <= 1'b0;
	else if((data_valid)&&(c_state == 2'b11))
		match <=1'b1;
	else
		match <= 1'b0;
end
endmodule

quartus综合出的状态转移图：
在这里插入图片描述
Testbench：

`timescale 1ns/1ns
module sequence_detect_1_tb();
	reg clk;
	reg rst_n;
	reg data;
	reg data_valid;
	wire match;
	
	
	sequence_detect_1 u0(
		.clk(clk),
		.rst_n(rst_n),
		.data(data),
		.data_valid(data_valid),
		.match(match)
	);
		
	always #10 clk = ~clk;
	
	initial begin
		clk= 0;
		rst_n = 0;
		data = 0;
		data_valid = 0;
		#20
		rst_n = 1;
		data = 0;
		data_valid = 1;		
		#20
		data = 1;
		#40
		data = 0;
		#20
		data_valid = 0;
		#20
		data = 1;
		#40
		data_valid = 1;
		data = 0;
		#20
		data_valid = 0;
		#20
		data_valid = 1;
		#20
		data = 1;
		#40
		data = 0;
		
		#200
		$stop;
	end	
endmodule

仿真结果：
在这里插入图片描述
因为只有data_valid拉高时，data数据才有效，所以当data为0110且data_valid同时拉高时，match才拉高。

移位寄存器写法
module sequence_detect_1(
	input clk,
	input rst_n,
	input data,
	input data_valid,
	output  reg match
	);
  reg[3:0]data_r;
  always@(posedge clk or negedge rst_n)begin
	if(!rst_n)
		data_r <= 4'b0;
	else if(data_valid)
		data_r <= {data_r[2:0],data};
	else 
		data_r <= data_r;
  end
  always@(posedge clk or negedge rst_n)begin
	if(!rst_n)
		match <= 1'b0;
	else if(({data_r[2:0],data} == 4'b0110)&&(data_valid == 1'b1))
		match <= 1'b1;
	else
		match <= 1'b0;
  end 
endmodule

Testbench：

`timescale 1ns/1ns
module sequence_detect_1_tb();
	reg clk;
	reg rst_n;
	reg data;
	reg data_valid;
	wire match;
	
	
	sequence_detect_1 u0(
		.clk(clk),
		.rst_n(rst_n),
		.data(data),
		.data_valid(data_valid),
		.match(match)
	);
		
	always #10 clk = ~clk;
	
	initial begin
		clk= 0;
		rst_n = 0;
		data = 0;
		data_valid = 0;
		#20
		rst_n = 1;
		data = 0;
		data_valid = 1;		
		#20
		data = 1;
		#40
		data = 0;
		#20
		data_valid = 0;
		#20
		data = 1;
		#40
		data_valid = 1;
		data = 0;
		#20
		data_valid = 0;
		#20
		data_valid = 1;
		#20
		data = 1;
		#40
		data = 0;
		
		#200
		$stop;
	end	
endmodule

仿真结果：
在这里插入图片描述
移位寄存器写法与状态机写法仿真结果一致

重叠和非重叠序列检测

重叠序列检测

设计一个状态机，用来检测序列 1011，要求：

1、进行重叠检测 即10110111 会被检测通过2次

2、寄存器输出，在序列检测完成下一拍输出检测有效

注意rst为低电平复位

状态机写法
module sequence_test1(
	input wire clk  ,
	input wire rst  ,
	input wire data ,
	output reg flag
);
localparam s0 = 5'b0_0001,
		   s1 = 5'b0_0010,
		   s2 = 5'b0_0100,
		   s3 = 5'b0_1000,
		   s4 = 5'b1_0000;
		  
reg[4:0]c_state,n_state;
always@(posedge clk or negedge rst)begin
	if(!rst)
		c_state <= s0;
	else
		c_state <= n_state;
end
always@(*)begin
	case(c_state)
		s0:n_state = data?s1:s0;
		s1:n_state = data?s1:s2;
		s2:n_state = data?s3:s0;
		s3:n_state = data?s4:s2;
		s4:n_state = data?s1:s2;
		default:n_state = s0;
	endcase
end
always@(posedge clk or negedge rst)begin
	if(!rst)
		flag <= 1'b0;
	else 
		flag <= (c_state == s4)?1'b1:1'b0;
end
endmodule

状态状态转移图;
在这里插入图片描述
Testbench：

`timescale 1ns/1ns
module sequence_test1_tb();
	reg clk;
	reg rst_n;
	reg data;
	wire flag;

	sequence_test1 u0(
		.clk(clk),
		.rst_n(rst_n),
		.data(data),
		.flag(flag)
	
	);
	
	always #10 clk = ~clk;
	
	initial begin
		clk = 0;
		rst_n = 0;
		data = 0;
		#10 rst_n =1;
		#20 data = 1;
		#20 data = 0;
		#20 data = 1;
		#20 data = 1;
		#20 data = 0;
		#20 data = 1;
		#20 data = 1;
		#20 data = 1;
		#20 data = 1;
		#200
		$stop;		
	end
endmodule

仿真结果;
在这里插入图片描述
10110111中进行1011的重叠检测会检测出两次！

非重叠序列检测

设计一个状态机，用来检测序列 10111，要求：

1、进行非重叠检测 即101110111 只会被检测通过一次

2、寄存器输出且同步输出结果

注意rst为低电平复位

verilog代码：

`timescale 1ns/1ns

module sequence_test2(
	input wire clk  ,
	input wire rst  ,
	input wire data ,
	output reg flag
);
//*************code***********//

localparam s0 = 6'b00_0001,
		   s1 = 6'b00_0010,
		   s2 = 6'b00_0100,
		   s3 = 6'b00_1000,
		   s4 = 6'b01_0000,
		   s5 = 6'b10_0000;
reg [5:0]c_state,n_state;
always@(posedge clk or negedge rst)begin
	if(!rst)
		c_state <= s0;
	else 
		c_state <= n_state;
end
always@(*)begin
	case(c_state)
		s0:n_state = data?s1:s0;
		s1:n_state = data?s1:s2;
		s2:n_state = data?s3:s0;
		s3:n_state = data?s4:s2;
		s4:n_state = data?s5:s2;
		s5:n_state = data?s1:s0;
		default:n_state = s0;
	endcase
end

always@(posedge clk or negedge rst)begin
	if(!rst)
		flag <= 1'b0;
	else if(n_state == s5)
		flag <= 1'b1;
	else
		flag <= 1'b0;
end

/*
reg [4:0]data_r;
always@(posedge clk or negedge rst)begin
	if(!rst)
		data_r <= 5'b0;
	else if(!flag)	
		data_r <= {data_r[3:0],data};
	else
		data_r <= 5'b0;
end
always@(posedge clk or negedge rst)begin
	if(!rst)
		flag <= 1'b0;
	else	
		flag <= {data_r[3:0],data} == 5'b10111;
end
*/
//*************code***********//
endmodule

注释部分为移位寄存器写法！

状态转移图：
在这里插入图片描述
Testbench：

`timescale 1ns/1ns
module sequence_test2_tb();
	reg clk;
	reg rst_n;
	reg data;
	wire flag;

	sequence_test2 u0(
		.clk(clk),
		.rst_n(rst_n),
		.data(data),
		.flag(flag)
	
	);
	
	always #10 clk = ~clk;
	
	initial begin
		clk = 0;
		rst_n = 0;
		data = 0;
		#10 rst_n =1;
		#20 data = 1;
		#20 data = 0;
		#20 data = 1;
		#20 data = 1;
		#20 data = 0;
		#20 data = 1;
		#20 data = 1;
		#20 data = 1;
		#20 data = 1;
		#200
		$stop;		
	end
endmodule

状态机写法仿真结果：
在这里插入图片描述
移位寄存器写法仿真结果：
在这里插入图片描述
可以看到两种写法达到的效果一样

更多关于序列的重叠和非重叠检测：序列检测_1011(重叠&不重叠检测)Verilog实现

含有无关项的序列检测

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

verilog代码：

module sequence_detect(
	input clk,
	input rst_n,
	input a,
	output reg match
	);

  
  reg[8:0]a_reg;
  always@(posedge clk or negedge rst_n)begin
	if(!rst_n)
		a_reg <= 8'd0;
	else
		a_reg <= {a_reg[7:0],a};
  end
  always@(posedge clk or negedge rst_n)begin
	if(!rst_n)
		match <= 1'b0;
	else if((a_reg[8:6] == 3'b011)&&(a_reg[2:0] == 3'b110))
		match <= 1'b1;
	else 
		match <= 1'b0;
  end
endmodule
FPGA个人练习生
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
检测序列11101000的帧头如何获取（附上源码）
Gerry
12-01 1693
教入门怎么获得你要检测序列的帧头，还是以我的上一篇文章为例。这里直接贴出源码以供大家参考学习。 （1） 源码 module seq_rd( input clk, input rst_n, input data_in, output [7:0] out_data0, output [7:0] out_data1, output [7:0] out_data2, output [7:0] o...
Verilog状态机序列检测器
11-09
本主题将深入探讨如何使用Verilog语言设计一个状态机来检测特定的序列，如"1101"，"11001"和"111110001"。我们将涵盖状态机的基础知识，Verilog编程语法，以及如何构建和验证序列检测器。 首先，让我们了解状态机的...
「Verilog学习笔记」 输入序列不连续的序列检测
最新发布
KS的博客
11-23 68
本专栏的内容主要是记录本人学习Verilog过程中的一些知识点，刷题网站用的是牛客网题目要求检测a的序列，a为单bit输入，每个时刻可能具有不同的值，且并不是每一个数据都是有效的，需要根据data_valid信号进行判断。在状态转化过程中，当data_valid为0，表示该时刻是输入数据无效，应保持在当前状态。当data_valid为1，再根据输入数据是否匹配进行下一个状态的值。
基于FPGA的UART多字节环回实验verilog代码(含帧头帧尾和解码部分)
芯想是陈的博客
04-09 2149
发送数据为：aa ff 03 00 0E 03 B1 86 10 00 40 01 11 00 00 00 00 00 00 00 11 00 00 00 00 00 11 11 55 CC。链接：https://pan.baidu.com/s/1M_E8hh8MNzZKfbq3mVitig?采用VIVADO开发环境，频率50MHz，波特率 256000，8位数据位，1位停止位。串口接收程序源自正点原子的例程。
Verilog | 序列检测
qq_45776815的博客
10-31 629
序列检测两种解法，一种是状态机写法， 一种是移位寄存器写法。
串行数据添加帧头以及帧头检测
weixin_43753381的博客
09-01 3754
发送链为串行数据添加帧头，接收链检测串行数据中的帧头，并完成环路测试。
20-Verilog HDL序列检测器设计.7z
03-09
本项目“20-Verilog HDL序列检测器设计”着重于使用Verilog实现一个序列检测器，该检测器在FPGA（现场可编程门阵列）平台上进行验证，并通过Vivado进行仿真。 序列检测器是一种数字电路，其功能是检测输入数据流中...
序列1101检测FPGA verilog实现
11-26
在提供的压缩包文件“xuliejiance_4”中，可能包含了该序列检测器的Verilog源代码、测试激励代码以及相关的文档或说明。通过阅读源代码和测试激励，我们可以深入了解设计的具体实现细节和测试方法。此外，这些文件也...
verilog代码 序列检测器
08-28
Verilog是一种广泛应用于硬件...总结来说，Verilog代码编写的序列检测器是一种利用状态机原理和FPGA技术实现的数字系统。通过理解和应用这些概念，可以设计出高效、灵活的序列检测解决方案，满足不同应用场景的需求。
M序列生成Verilog代码
07-17
m序列生成代码。
序列检测器的verilog实现
热门推荐
小菜鸡
01-17 1万+
序列检测同步时序逻辑电路，要实现的功能如下： 当已有输入码流出现序列111000或101110时输出检测信号为1，否则输出为0。 在时序上检测到完整序列的下一个时钟周期输出检测结果。 输入信号有效为1时表示当前输入有效，否则表示无效。 之前输入依旧计入序列中并不清零，即允许序列重叠检测。
verilog实现10011序列检测器
yh13572438258的博客
12-30 7927
目录 状态机简介 模块设计代码如下： 测试平台如下： Makefile仿真脚本VCS+Verdi run.tcl文件 仿真波形 状态机简介 本文设计了一个“10011”序列检测器，采用moore型状态机进行了设计。 Moore型状态机：输出只由当前状态决定，即次态=f(现状，输入)，输出=f（现状）； Mealy型状态机：输出不但与当前状态有关，还与当前输入值有关，即次态=f(现状，输入)，输出=f（现状，输入）； 下面是摩尔型状态转移图 模块设计代码如下： `ti...
verilog手撕代码3——序列检测和序列发生器
qq_42135020的博客
04-26 5183
序列检测、序列生成
Verilog-实现基于状态机的序列检测--一段式状态机、二段式状态机、三段式状态机
Anzg256的博客
04-12 3184
将时序逻辑和组合逻辑划分开来，时序逻辑进行当前状态和下一状态的切换，组合逻辑实现输入、输出以及状态的判断，这种写法相对容易维护，不过组合逻辑输出容易出现毛刺等问题。代码易维护，时序逻辑的输出解决了二段式写法中组合逻辑的毛刺问题，但是三段式消耗的资源相对多一点，并且三段式从输入到输出比一段式和二段式会延时一个时钟周期。将所有的逻辑（输入、输出、状态）在一个always块里进行描述，这种写法看起来简单，但对于复杂的状态会容易出错，并且在大型项目中这些代码是不利于维护的。的工作，这就要用到状态机的思想。
verilog 四种序列检测 方法总结（连续/含有无关项/不重叠/带使能信号）
weixin_44413306的博客
11-30 1402
分别对1、序列连续的信号检测 2、带有无关项的序列检测 3、不重叠序列检测 4、带有使能信号的序列检测 进行了代码编写。
FPGA基本功之数据帧检测
wo_cai_niao的博客
01-25 993
若不为帧尾则为有效数据，每收到16bit数据进行输出，并拉高data_valid信号（持续一个clk）；继续检测该数据流是否为帧尾，如果为帧尾，本次数据提取结束；如果不为帧尾，仍为有效数据，重复上述过程，直到数据结束。定义一个数据帧，帧头为8'he，帧尾为8'hff（有效数据不包含帧尾），当数据输入时开始检测，若检测到帧头后直接检测到帧尾，则认为数据帧为空包，拉高abort信号（持续一个clk）；
m基于UW序列的数据帧检测,帧同步verilog实现,含testbench
fpga/matlab/simulink算法仿真工程
07-28 385
在发送端，数据帧的头部会与UW序列进行异或操作，然后发送给接收端。然后，选择一个合适的UW序列，并将数据帧的头部依次与UW序列进行异或操作。在数据帧检测中，发送端会将数据帧的头部与UW序列进行异或操作，接收端通过检测UW序列的出现来识别数据帧的起始位置和帧同步。互相关运算：将接收到的数据流与选定的UW序列进行互相关运算，得到互相关结果R。平衡性：UW序列中的1和0的数量大致相等，确保序列具有良好的自相关性。选择UW序列：在接收端选择与发送端使用的UW序列相同的UW序列。
m基于双PN序列的数据帧检测,帧同步verilog实现,含testbench
fpga/matlab/simulink算法仿真工程
07-28 462
基于双PN序列的数据帧检测和帧同步是一种在通信系统中常用的技术，用于确保接收端正确地识别和解析传输的数据帧。在本文中，我将详细介绍基于双PN序列的数据帧检测的数学原理和实现过程，并探讨其在FPGA（现场可编程门阵列）中的应用领域。然后，选择两个合适的PN序列PNA和PNB，并将数据帧的头部、数据和尾部依次与这两个序列进行异或操作。基于双PN序列的数据帧检测和帧同步在许多通信系统中都有广泛的应用，尤其是在接收端解析复杂的数据帧时。在接收端，我们会使用这两个双PN序列来检测数据帧的起始位置和帧同步。
verilog手撕代码6——数据包检测器
qq_42135020的博客
05-07 465
verilog实现数据包检测
verilog不重叠序列检测
03-25
Verilog中实现不重叠序列检测可以使用以下代码： ```verilog module not_overlap_seq_detection ( input clk, input reset, input data, output reg detect ); reg [1:0] state; parameter s0 = 2'b00, s1 = 2'b01, s2 = 2'b10; always @(posedge clk or posedge reset) begin if (reset) begin state <= s0; // reset时，将state设置为s0 detect <= 0; end else begin case (state) s0: begin // 当state为s0时 if (data) begin // 如果输入data为1 state <= s1; // 转移到s1状态 end else begin state <= s0; // 否则，保持在s0状态 end end s1: begin // 当state为s1时 if (data) begin // 如果输入data为1 state <= s2; // 转移到s2状态 detect <= 1; // 并将detect置为1 end else begin state <= s0; // 否则，回到s0状态 end end s2: begin // 当state为s2时 if (!data) begin // 如果输入data为0 state <= s0; // 回到s0状态 end else begin state <= s2; // 否则，保持在s2状态 end end endcase end end endmodule ``` 这个模块会检测输入数据序列是否重叠，如果重叠，则会在输入数据序列中检测到一个1。如果检测到一个1，则该模块会将输出`detect`置为1。如果输入数据序列中的所有1都没有重叠，则该模块的输出`detect`将保持为0。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值