基于verlog语言的UART通信协议模块实现

最新推荐文章于 2023-04-13 08:30:00 发布
最新推荐文章于 2023-04-13 08:30:00 发布
阅读量283 收藏 1
点赞数 2
分类专栏： FPGA、verilog、通信协议 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/God_zlg/article/details/126310640
版权

前言

在此我就不对UART协议细节部分做介绍，网上相关的介绍太多了。目前通过串口调试助手成功实现板载时钟50MHz情况下最大波特率3000000 bit/s通信。

模块组成

顶层：uart_modu
底层：uart_tx_modu、uart_rx_modu

模块接口

顶层

uart_modu #(
   .CLK_FRE  (50)	,	//模块时钟，单位MHz
   .BAUD_RATE(115200)	//通信波特率
)
your_instance_name(
	.clk		(clk		)		,	//input[0:0]模块时钟输入
	.rst		(rst		)		,	//input[0:0]模块复位输入，高电平有效

	.i_tx_begin	(i_tx_begin	)		,	//input[0:0]开始发送信号输入
	.i_tx_data	(i_tx_data	)		,	//input[7:0]待发送数据输入
	.o_tx_done	(o_tx_done	)		,	//output[0:0]发送完成标志输出
	.o_tx_busy	(o_tx_busy	)		,	//output[0:0]模块忙碌标志
	.o_tx_pin	(o_tx_pin	)		,	//output[0:0]发送引脚

	.o_rx_data	(o_rx_data	)		,	//output[7:0]接收数据输出
	.o_rx_vald	(o_rx_vald	)		,	//output[0:0]接收数据有效标志
	.o_rx_done	(o_rx_done	)		,	//output[0:0]接收完成标志
	.o_rx_busy	(o_rx_busy	)		,	//output[0:0]模块忙碌标志
	.i_rx_pin	(i_rx_pin	)			//input[0:0]接收引脚
    );

底层

uart_tx_modu #(
   .CLK_FRE  (50)	,	//模块时钟，单位MHz
   .BAUD_RATE(115200)	//通信波特率
)
your_instance_name(
	.clk		(clk		),	//input[0:0]模块时钟输入
	.rst		(rst		),	//input[0:0]模块复位输入，高电平有效
	.tx_begin	(tx_begin	),	//input[0:0]开始发送信号输入
	.tx_data	(tx_data	),	//input[7:0]待发送数据输入
	.tx_done	(tx_done	),	//output[0:0]发送完成标志输出
	.tx_busy	(tx_busy	),	//output[0:0]模块忙碌标志
	.tx_pin		(tx_pin		)	//output[0:0]发送引脚
    );

uart_rx_modu #(
   .CLK_FRE  (50)	,	//模块时钟，单位MHz
   .BAUD_RATE(115200)	//通信波特率
)
your_instance_name(
	.clk		(clk		),	//input[0:0]模块时钟输入
	.rst		(rst		),	//input[0:0]模块复位输入，高电平有效
	.rx_data	(rx_data	),	//output[7:0]接收数据输出
	.rx_vald	(rx_vald	),	//output[0:0]接收数据有效标志
	.rx_done	(rx_done	),	//output[0:0]接收完成标志
	.rx_busy	(rx_busy	),	//output[0:0]模块忙碌标志
	.rx_pin		(rx_pin		)	//input[0:0]接收引脚
);

时许仿真

tx_modu

测试代码

module tx_debug();

localparam	CUN = 10;

always #(CUN) clk = ~clk;

reg		[0:0]	clk		 = 1'b0;
reg		[0:0]	rst		 = 1'b0;
reg		[0:0]	tx_begin = 1'b0;	
reg		[7:0]	tx_data	 = 8'hA5;
wire	[0:0]	tx_done	;
wire	[0:0]	tx_busy	;
wire	[0:0]	tx_pin 	;

initial begin 
	#(CUN*4)	rst		 = 1'b1;
	#(CUN*2)	rst		 = 1'b0;

	#(CUN*4)	tx_begin = 1'b1;
	#(CUN*2)	tx_begin = 1'b0;

end

uart_tx_modu #(
   .CLK_FRE  (50)	,		//模块时钟，单位MHz
   .BAUD_RATE(115200)		//通信波特率
)
uart_tx_debug(
	.clk		(clk		)	,	//input[0:0]模块时钟输入
	.rst		(rst		)	,	//input[0:0]模块复位输入，高电平有效
	.tx_begin	(tx_begin	)	,	//input[0:0]开始发送信号输入
	.tx_data	(tx_data	)	,	//input[7:0]待发送数据输入
	.tx_done	(tx_done	)	,	//output[0:0]发送完成标志输出
	.tx_busy	(tx_busy	)	,	//output[0:0]模块忙碌标志
	.tx_pin		(tx_pin		)		//output[0:0]发送引脚
    );
endmodule

仿真截图

发送模块时许仿真

rx_modu

仿真源代码

module rx_debug();

localparam	CUN = 10;

always #(CUN) clk = ~clk;

reg		[0:0]	clk = 1'b0;		//模块时钟输入
reg		[0:0]	rst = 1'b0;		//模块复位输入，高电平有效
wire	[7:0]	rx_data;		//接收数据输出
wire	[0:0]	rx_vald;		//接收数据有效标志
wire	[0:0]	rx_done;		//接收完成标志
wire	[0:0]	rx_busy;		//模块忙碌标志
reg		[0:0]	rx_pin = 1'b1;	//接收引脚


initial begin 
	#(CUN*4)	rst		 = 1'b1;
	#(CUN*2)	rst		 = 1'b0;
	
	#(CUN*4)	rx_pin	 = 1'b0; //
	#8680		rx_pin	 = 1'b1; //1
	#8680		rx_pin	 = 1'b0; //2
	#8680		rx_pin	 = 1'b1; //3 
	#8680		rx_pin	 = 1'b0; //4 
	#8680		rx_pin	 = 1'b1; //5 
	#8680		rx_pin	 = 1'b0; //6 
	#8680		rx_pin	 = 1'b1; //7 
	#8680		rx_pin	 = 1'b0; //8 
	#8680		rx_pin	 = 1'b1; //
end

uart_rx_modu #(
   .CLK_FRE  (50)	,	//模块时钟，单位MHz
   .BAUD_RATE(3000000)	//通信波特率
)
uart_tx_debug(
	.clk		(clk		),	//input[0:0]模块时钟输入
	.rst		(rst		),	//input[0:0]模块复位输入，高电平有效
	.rx_data	(rx_data	),	//output[7:0]接收数据输出
	.rx_vald	(rx_vald	),	//output[0:0]接收数据有效标志
	.rx_done	(rx_done	),	//output[0:0]接收完成标志
	.rx_busy	(rx_busy	),	//output[0:0]模块忙碌标志
	.rx_pin		(rx_pin		)	//input[0:0]接收引脚
    );
endmodule

仿真截图

接收模块时许仿真

源码

顶层

/*===============================================
//----------- Begin Cut here for uart_modu Template ---//
uart_modu #(
   .CLK_FRE  (50)	,	//模块时钟，单位MHz
   .BAUD_RATE(115200)	//通信波特率
)
your_instance_name(
	.clk		(clk		)		,	//input[0:0]模块时钟输入
	.rst		(rst		)		,	//input[0:0]模块复位输入，高电平有效

	.i_tx_begin	(i_tx_begin	)		,	//input[0:0]开始发送信号输入
	.i_tx_data	(i_tx_data	)		,	//input[7:0]待发送数据输入
	.o_tx_done	(o_tx_done	)		,	//output[0:0]发送完成标志输出
	.o_tx_busy	(o_tx_busy	)		,	//output[0:0]模块忙碌标志
	.o_tx_pin	(o_tx_pin	)		,	//output[0:0]发送引脚

	.o_rx_data	(o_rx_data	)		,	//output[7:0]接收数据输出
	.o_rx_vald	(o_rx_vald	)		,	//output[0:0]接收数据有效标志
	.o_rx_done	(o_rx_done	)		,	//output[0:0]接收完成标志
	.o_rx_busy	(o_rx_busy	)		,	//output[0:0]模块忙碌标志
	.i_rx_pin	(i_rx_pin	)			//input[0:0]接收引脚
    );
// INST_TAG_END ------ End uart_modu Template ---------
===============================================*/

module uart_modu#(
	parameter	[7:0]	CLK_FRE   = 50,		//The clock frequency at which the module works, in MHz
	parameter	[23:0]	BAUD_RATE = 115200	//Communication baud rate
)(
	input	wire[0:0]	clk			,	//模块时钟，单位MHz
	input	wire[0:0]	rst			,	//通信波特率
	
	input	wire[0:0]	i_tx_begin	,	//input[0:0]开始发送信号输入
	input	wire[7:0]	i_tx_data	,	//input[7:0]待发送数据输入
	output	wire[0:0]	o_tx_done	,	//output[0:0]发送完成标志输出
	output	wire[0:0]	o_tx_busy	,	//output[0:0]模块忙碌标志
	output	wire[0:0]	o_tx_pin	,	//output[0:0]发送引脚

	output	wire[7:0]	o_rx_data	,	//output[7:0]接收数据输出
	output	wire[0:0]	o_rx_vald	,	//output[0:0]接收数据有效标志
	output	wire[0:0]	o_rx_done	,	//output[0:0]接收完成标志
	output	wire[0:0]	o_rx_busy	,	//output[0:0]模块忙碌标志
	input	wire[0:0]	i_rx_pin		//input[0:0]接收引脚
    );

	wire	[0:0]	clk_i	;
	wire	[0:0]	rst_i	;
	wire	[0:0]	tx_begin;	
	wire	[0:0]	tx_data	;
	wire	[0:0]	tx_done	;
	wire	[0:0]	tx_busy	;
	wire	[0:0]	tx_pin	;	
	wire	[0:0]	rx_data	;
	wire	[0:0]	rx_vald	;
	wire	[0:0]	rx_done	;
	wire	[0:0]	rx_busy	;
	wire	[0:0]	rx_pin	;	
	
	assign	clk_i		= clk		;
	assign	rst_i		= rst       ;
	assign	tx_begin	= i_tx_begin;	
	assign	tx_data		= i_tx_data	;
	assign	o_tx_done	= tx_done	;
	assign	o_tx_busy	= tx_busy	;
	assign	o_tx_pin	= tx_pin	;
	assign	o_rx_data	= rx_data	;
	assign	o_rx_done	= rx_done	;
	assign	o_rx_busy	= rx_busy	;
	assign	rx_pin		= i_rx_pin  ;

uart_tx_modu #(
   .CLK_FRE  	(CLK_FRE	),	//模块时钟，单位MHz
   .BAUD_RATE	(BAUD_RATE	)	//通信波特率
)
uart_tx_modu_u(
	.clk		(clk_i		),	//input[0:0]模块时钟输入
	.rst		(rst_i		),	//input[0:0]模块复位输入，高电平有效
	.tx_begin	(tx_begin	),	//input[0:0]开始发送信号输入
	.tx_data	(tx_data	),	//input[7:0]待发送数据输入
	.tx_done	(tx_done	),	//output[0:0]发送完成标志输出
	.tx_busy	(tx_busy	),	//output[0:0]模块忙碌标志
	.tx_pin		(tx_pin		)	//output[0:0]发送引脚
    );

uart_rx_modu #(
   .CLK_FRE  	(CLK_FRE	),	//模块时钟，单位MHz
   .BAUD_RATE	(BAUD_RATE	)	//通信波特率
)
uart_rx_modu_u(
	.clk		(clk		),	//input[0:0]模块时钟输入
	.rst		(rst		),	//input[0:0]模块复位输入，高电平有效
	.rx_data	(rx_data	),	//output[7:0]接收数据输出
	.rx_vald	(rx_vald	),	//output[0:0]接收数据有效标志
	.rx_done	(rx_done	),	//output[0:0]接收完成标志
	.rx_busy	(rx_busy	),	//output[0:0]模块忙碌标志
	.rx_pin		(rx_pin		)	//input[0:0]接收引脚
    );
endmodule

底层

rx_modu
/*===============================================
//----------- Begin Cut here for usrt_rx_modu Template ---//
uart_rx_modu #(
   .CLK_FRE  (50)	,	//模块时钟，单位MHz
   .BAUD_RATE(115200)	//通信波特率
)
your_instance_name(
	.clk		(clk		),	//input[0:0]模块时钟输入
	.rst		(rst		),	//input[0:0]模块复位输入，高电平有效
	.rx_data	(rx_data	),	//output[7:0]接收数据输出
	.rx_vald	(rx_vald	),	//output[0:0]接收数据有效标志
	.rx_done	(rx_done	),	//output[0:0]接收完成标志
	.rx_busy	(rx_busy	),	//output[0:0]模块忙碌标志
	.rx_pin		(rx_pin		)	//input[0:0]接收引脚
    );
// INST_TAG_END ------ End usrt_rx_modu Template ---------
===============================================*/

module uart_rx_modu #(
	parameter	[7:0]	CLK_FRE   = 50,		//The clock frequency at which the module works, in MHz
	parameter	[23:0]	BAUD_RATE = 115200	//Communication baud rate
)(
	input	wire[0:0]	clk				,	//input[0:0]模块时钟输入
	input	wire[0:0]	rst				,	//input[0:0]模块复位输入，高电平有效

	output	wire[7:0]	rx_data			,	//output[7:0]接收数据输出
	output	wire[0:0]	rx_vald			,	//output[0:0]接收数据有效标志
	output	wire[0:0]	rx_done			,	//output[0:0]接收完成标志
	output	wire[0:0]	rx_busy			,	//output[0:0]模块忙碌标志

	input	wire[0:0]	rx_pin				//input[0:0]接收引脚
);

/*===========计算当前时钟与波特率下bit持续时钟周期==========*/
	localparam	[15:0]	BIT_CYCLE1 = CLK_FRE * 1_000_000 / BAUD_RATE;
	localparam	[15:0]	BIT_CYCLE2 = CLK_FRE * 1_000_000 / BAUD_RATE/2;
/************************************************************/

/*=========================定义状态=========================*/
	localparam	[1:0]	S_IDLE		= 2'd0;		//空闲状态
	localparam	[1:0]	S_START		= 2'd1;     //接收开始信号
	localparam	[1:0]	S_SEND		= 2'd2;     //接收数据
	localparam	[1:0]	S_STOP		= 2'd3;     //接收结束信号
/************************************************************/

/*=========================定义寄存器=========================*/
	wire	[0:0]		start				;	//开始信号上升沿标志
	reg		[1:0]		start_r2	= 2'd3	;	//检测寄存器
	reg		[2:0]		now_state	= 3'd0	; 	//当前状态寄存器
	reg		[2:0]		nex_state	= 3'd0	; 	//下一状态寄存器
	reg		[31:0]		time_cnt	= 32'd0	;	//bit周期计时器
	reg		[2:0]		bit_cnt		= 3'd0	;	//bit计数器
	reg		[2:0]		rx_bit_reg	= 3'd0	;	//
	reg		[7:0]		rx_data_reg = 8'd0	;
/************************************************************/

/*=========================输出信号=========================*/
	assign	rx_busy = (now_state == S_IDLE) ? 1'b0 : 1'b1;
	assign	rx_done = (now_state == S_STOP && time_cnt == BIT_CYCLE2- 'd1) ? 1'b1 : 1'b0;
	assign	rx_data = (bit_cnt == 3'd7 && time_cnt >= BIT_CYCLE2 + 'd4) ? rx_data_reg : 8'd0;
	assign	rx_vald = (bit_cnt == 3'd7 && (time_cnt == BIT_CYCLE1 - 'd4 || time_cnt == BIT_CYCLE1 - 'd3)) ? 1'b1 : 1'b0;
/************************************************************/

/*=========================捕获开始信号=========================*/
	always@ (posedge clk)
		begin 
			if(now_state == S_IDLE)
				start_r2 <= {start_r2[0],rx_pin};
			else 
				start_r2 <= 2'd3;
		end 
	assign	start = start_r2[1] & ~start_r2[0];
/************************************************************/

/*======================bit周期计时器=======================*/
	always@ (posedge clk)
		begin
			if(now_state == S_IDLE)
				time_cnt <= 32'd0;
			else if(time_cnt == BIT_CYCLE1 - 1'b1 || (now_state == S_START && time_cnt == BIT_CYCLE1 - 'd2))
				time_cnt <= 32'd0;
			else
				time_cnt <= time_cnt + 1'b1;
		end 
/************************************************************/

/*========================bit计数器=========================*/
	always@ (posedge clk)
		begin 
			if(now_state != S_SEND)
				bit_cnt <= 3'd0;
			else if(time_cnt == BIT_CYCLE1 - 1'b1)
				bit_cnt <= bit_cnt + 1'b1;
		end 
/************************************************************/

/*=================接收单bit数据并均值滤波==================*/
	always@ (posedge clk)
		begin 
			if(now_state == S_IDLE)
				rx_bit_reg <= 3'd0;
			else if(now_state == S_SEND && time_cnt == BIT_CYCLE1 - 'd2)
				rx_bit_reg <= 3'd0;
			else if(now_state == S_SEND && (time_cnt == BIT_CYCLE2 - 'd4 || time_cnt == BIT_CYCLE2 - 'd3 || time_cnt == BIT_CYCLE2 - 'd2 || time_cnt == BIT_CYCLE2 - 'd1 || time_cnt == BIT_CYCLE2		  || time_cnt == BIT_CYCLE2 + 'd1 || time_cnt == BIT_CYCLE2 + 'd2))
				rx_bit_reg <= rx_bit_reg + rx_pin;
			else 
				rx_bit_reg <= rx_bit_reg;
		end
/************************************************************/

/*=====================寄存接收到的数据=====================*/
	always@ (posedge clk)
		begin 
			if(now_state == S_IDLE)
				rx_data_reg <= 8'd0;
			else if(now_state == S_SEND && time_cnt == BIT_CYCLE2 + 'd4)
				rx_data_reg[bit_cnt] <= rx_bit_reg[2];
			else 
				rx_data_reg <= rx_data_reg;
		end
/************************************************************/

/*=========================状态转换=========================*/
	always@ (posedge clk or posedge rst)
		begin 
			if(rst)
				now_state <= S_IDLE;
			else 
				now_state <= nex_state;
		end 
/************************************************************/

/*=========================下一状态=========================*/
	always@ (*)
		begin 
			case(now_state)
				S_IDLE	:
					begin 
						if(start)
							nex_state = S_START;
						else 
							nex_state = S_IDLE;
					end 
				S_START	:
					begin 
						if(time_cnt == BIT_CYCLE1 - 'd2)
							nex_state = S_SEND;
						else 
							nex_state = S_START;
					end 
				S_SEND	:
					begin 
						if(time_cnt == BIT_CYCLE1 - 1'b1 && bit_cnt == 3'd7)
							nex_state = S_STOP;
						else 
							nex_state = S_SEND;
					end 
				S_STOP	:
					begin 
						if(time_cnt == BIT_CYCLE2)
							nex_state = S_IDLE;
						else 
							nex_state = S_STOP;
					end 
				default	:nex_state = S_IDLE;
			endcase
		end
/************************************************************/
endmodule
tx_modu
/*===============================================
//----------- Begin Cut here for uart_tx_modu Template ---//
uart_tx_modu #(
   .CLK_FRE  (50)	,	//模块时钟，单位MHz
   .BAUD_RATE(115200)	//通信波特率
)
your_instance_name(
	.clk		(clk		),	//input[0:0]模块时钟输入
	.rst		(rst		),	//input[0:0]模块复位输入，高电平有效
	.tx_begin	(tx_begin	),	//input[0:0]开始发送信号输入
	.tx_data	(tx_data	),	//input[7:0]待发送数据输入
	.tx_done	(tx_done	),	//output[0:0]发送完成标志输出
	.tx_busy	(tx_busy	),	//output[0:0]模块忙碌标志
	.tx_pin		(tx_pin		)	//output[0:0]发送引脚
    );
// INST_TAG_END ------ End uart_tx_modu Template ---------
===============================================*/

module uart_tx_modu#(
	parameter	[7:0]	CLK_FRE   = 50,		//The clock frequency at which the module works, in MHz
	parameter	[23:0]	BAUD_RATE = 115200	//Communication baud rate
)(
	input	wire[0:0]	clk				,	//input[0:0]模块时钟输入
	input	wire[0:0]	rst				,	//input[0:0]模块复位输入，高电平有效

	input	wire[0:0]	tx_begin		,	//input[0:0]开始发送信号输入
	input	wire[7:0]	tx_data			,	//input[7:0]待发送数据输入
	output	wire[0:0]	tx_done			,	//output[0:0]发送完成标志输出
	output	wire[0:0]	tx_busy			,	//output[0:0]模块忙碌标志

	output	wire[0:0]	tx_pin				//output[0:0]发送引脚
);

/*===========计算当前时钟与波特率下bit持续时钟周期==========*/
	localparam	[15:0]	BIT_CYCLE = CLK_FRE * 1_000_000 / BAUD_RATE;
/************************************************************/

/*=========================定义状态=========================*/
	localparam	[1:0]	S_IDLE		= 2'd0;		//空闲状态
	localparam	[1:0]	S_START		= 2'd1;     //发送开始信号
	localparam	[1:0]	S_SEND		= 2'd2;     //发送数据
	localparam	[1:0]	S_STOP		= 2'd3;     //发送结束信号
/************************************************************/

/*========================定义寄存器========================*/
	reg		[1:0]		start_r2	= 2'd0	;	//开始信号缓存器
	wire	[0:0]		start				;	//开始信号上升沿标志
	reg		[2:0]		now_state	= 3'd0	; 	//当前状态寄存器
	reg		[2:0]		nex_state	= 3'd0	; 	//下一状态寄存器
	reg		[31:0]		time_cnt	= 32'd0	;	//bit周期计时器
	reg		[2:0]		bit_cnt		= 3'd0	;	//bit计数器
	reg		[7:0]		tx_data_reg = 8'd0	;	//待发送数据寄存器
	reg		[0:0]		tx_reg		= 1'd1	;	//待发送bit寄存器
/************************************************************/

/*===================-=====输出端口=========================*/
	assign	tx_done = (now_state == S_STOP && time_cnt == BIT_CYCLE-1) ? 1'b1 : 1'b0;
	assign	tx_busy = (now_state == S_IDLE) ? 1'b0 : 1'b1;
	assign	tx_pin  = (now_state == S_IDLE) ? 1'b1 : tx_reg;
/************************************************************/

/*====================产生开始信号上升沿====================*/
	always@ (posedge clk)
		begin 
			if(now_state == S_IDLE)
				start_r2 <= {start_r2[0],tx_begin};
			else
				start_r2 <= 2'd0;
		end 
	assign	start = ~start_r2[1] & start_r2[0];
/************************************************************/

/*======================bit周期计时器=======================*/
	always@ (posedge clk)
		begin
			if(now_state == S_IDLE)
				time_cnt <= 32'd0;
			else if(time_cnt == BIT_CYCLE - 1'b1)
				time_cnt <= 32'd0;
			else
				time_cnt <= time_cnt + 1'b1;
		end 
/************************************************************/

/*========================bit计数器=========================*/
	always@ (posedge clk)
		begin 
			if(now_state != S_SEND)
				bit_cnt <= 3'd0;
			else if(time_cnt == BIT_CYCLE - 1'b1)
				bit_cnt <= bit_cnt + 1'b1;
		end 
/************************************************************/

/*======================寄存待发送数据======================*/
	always@ (posedge clk)
		begin 
			if(now_state == S_IDLE && nex_state == S_IDLE)
				tx_data_reg <= 8'd0;
			else if(now_state == S_IDLE && nex_state != S_IDLE)
				tx_data_reg <= tx_data;
			else 
				tx_data_reg <= tx_data_reg;
		end 
/************************************************************/

/*=========================产生输出=========================*/
	always@ (posedge clk)
		begin 
			if(now_state == S_IDLE)
				tx_reg <= 1'b1;
			else if(now_state == S_START)
				tx_reg <= 1'b0;
			else if(now_state == S_SEND)
				tx_reg <= tx_data_reg[bit_cnt];
			else if(now_state == S_STOP)
				tx_reg <= 1'b1;
		end 
/************************************************************/

/*=========================状态切换=========================*/
	always@ (posedge clk or posedge rst)
		begin 
			if(rst)
				now_state <= S_IDLE;
			else 
				now_state <= nex_state;
		end 
/************************************************************/

/*=======================产生下一状态=======================*/
	always@ (*)
		begin 
			case(now_state)
				S_IDLE	:
					begin 
						if(start)
							nex_state = S_START;
						else 
							nex_state = S_IDLE;
					end
				S_START	:
					begin 
						if(time_cnt == BIT_CYCLE - 1'b1)
							nex_state = S_SEND;
						else 
							nex_state = S_START;
					end
				S_SEND	:
					begin 
						if(time_cnt == BIT_CYCLE - 1'b1 && bit_cnt == 3'd7)
							nex_state = S_STOP;
						else 
							nex_state = S_SEND;
					end
				S_STOP	:
					begin 
						if(time_cnt == BIT_CYCLE - 1'b1)
							nex_state = S_IDLE;
						else 
							nex_state = S_STOP;
					end
				default	:begin nex_state = S_IDLE; end
			endcase
		end
/************************************************************/
endmodule

结束语

本人刚刚入坑FPGA 不久，在代码风格，设计逻辑上还有很多不足之处。欢迎各位大佬指出我的不住之处。

zlg_good
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
UART自适应任意（典型）波特率原理以及FPGA实现
主要分享学习中的知识和遇到的问题
04-17 2452
一种方案就能让通信双方不约定波特率，主机按照主机的波特率发送数据，从机自适应调整自己的波特率跟主机通信。在实际中可以采用特征值匹配的方法实现自适应波特率发生器。
Verilog实现串口通讯（UART）
Master_0_的博客
08-04 8220
Verilog实现串口通讯（UART） 本代码参考了野火的相关教程，实现了发送和接收回环，同时可以通过串口数据控制LED灯的亮灭，在电脑发送数据时要选择HEX发送模式，发送16进制的数据进行控制。 UART协议中，在空闲时为高电平。在常用的一位停止位和无校验位的设置中，起始位为低电平，紧接着是8位的数据位，最后是一位高电平的停止位。 接收模块 ​ 接收模块的主要设计是将起始位下降沿的检测作为接收系统的开始信号，通过起始信号和bit位的计数信号相结合就可以得到一个贯穿整体运行过程的使能信号，通过对使能信号的判
Verilog UART(1)：TX模块
Fantasy237的博客
08-22 939
Verilog UART(1)：TX模块
stm32+RTThread串口在高波特率踩坑
u012936480的博客
10-13 1953
项目场景： 需要stm32f4的串口使用3000000+的波特率。 问题描述： 串口的中断接收平时都是使用115200或9600的波特率，在使用较高波特率时按照常用波特率的使用方法会出现无法读取或截断的情况。且用CubeMX配置时会出现波特率误差警告。 解决方案： 问题出现的原因可能是系统中断接收处理不过来，导致出现接收数据被截断的情况。 二是有些串口在16位采样时无法配置到那么高的波特率。 想要配置高波特率，按照参考手册里的说明，需要将采样率从16位降到8位。 RTThread的串口初始化里，默
查看串口波特率、停止位数、奇偶校验位信息，更改COM
Electrical_IT的博客
07-06 1914
转载： [串口如何确定波特率-百度经验https://jingyan.baidu.com/article/4f34706e8ae829a287b56d9b.html] (https://jingyan.baidu.com/article/4f34706e8ae829a287b56d9b.html)
XCOM_v2.6.zip
01-08
XCOM, 包含1000000、2000000、3000000的波特率
UART.zip_uart verilog_verilog实现uart_verilog语言uart
09-21
标题中的“UART.zip_uart verilog_verilog实现uart_verilog语言uart”表明这是一个关于使用Verilog语言实现UART功能的项目压缩包。这个项目可能包含了完整的UART模块设计，以及相关的测试环境和验证案例。 描述中...
UART发送模块，Verilog语言实现
最新发布
03-18
UART 协议定义了数据的传输格式和通信规则，使得不同设备之间能够进行可靠的数据交换。 代码中采用三段式状态机： IDLE：空闲状态，无数据传输，输出高电平，当i_valid信号到来时跳转到START状态； START：起始位...
基于Verilog HDL的UART模块设计与仿真
01-19
采用自顶向下的设计路线，结合状态机的描述形式，使用硬件描述语言设计UART的顶层模块及各个子模块，从而使整个设计更加紧凑、可靠。同时采用参数化的设计方法，增强系统的可移植性。仿真结果表明，该系统可支持标准...
基于FPGA开发的UART通信模块
01-30
在本项目中，“基于FPGA开发的UART通信模块”是一个专为FPGA（现场可编程门阵列）设计的硬件IP核，允许用户通过Verilog语言进行自定义和修改，以适应不同的应用需求。 首先，我们要理解UART通信的基本原理。UART...
E:\数字电路与逻辑设计\数字电路基础
10-14
E:\数字电路与逻辑设计\数字电路基础 E:\数字电路与逻辑设计\数字电路基础
收藏！了解UART总线工作原理看这一篇就够了！
liming0931的专栏
09-01 1647
原文：玩转单片机 2019-08-24 16:50:29 越学到后面，基础知识更加不能忘记，温故而知新~~ 还记得当年的打印机，鼠标和调制解调器吗？他们都有巨大笨重的连接器和粗电缆，并且必须拧到你的电脑上。这些设备正是使用UART协议与计算机进行通信。虽然USB几乎完全取代了旧的电缆和连接器，但UART绝对没有过时。您会发现目前许多项目中使用UART的GPS模块、蓝牙模块和RFID读卡器...
基于verilog实现的UART
qq_42357476的博客
11-30 397
本文介绍通用异步收发器（Univeral Asynchronous Receiver/Transmitter，UART）的基本原理，并且使用verilog实现UART，编写测试文件验证UART正确性。
Verilog(1)UART串口通信
m0_55542784的博客
11-22 2535
UART串口通信
Verilog-UART串口通信协议
Anzg256的博客
04-13 2195
uart：通用异步收发传输器（Universal Asynchronous Receiver/Transmitter)，是一种通用串行数据总线，用于异步通信。uart能实现双向通信，在嵌入式设计中，它常用于主机与辅助设备通信。uart包括RS232、RS449、RS432、RS422和RS485等接口标准规范和总线标准规范，既uart是异步串行通信口的的总称。
Verilog实现的UART串口 RX模块与testbench代码
qq_35622134的博客
06-25 4345
如图所示.本串口RX模块包含 RX信号线，时钟Clk、 接收完成标志 rdsig ，数据错误dataerror（奇偶校验），格式错误（停止位）、数据接收结果dataout[7:0]。 基于这样的结构。以下是模块的Verilog实现代码，其中一些变量名有所改变： UART_RX: `timescale 1ns / 1ps ////////////////...
EFM32 LEUART波特率计算
OverLord的博客
02-16 1073
LEUART和EFM32单片机中的其他LE外围设备一样，可以由三个不同的时钟源驱动，低频射频振荡器(LFRCO)、低频晶体振荡器(LFXO)和除以2或4的高频核心时钟(HFCORECLK_LE/2，HFCORECLK_LE/4)。HFCORECLK_LE又可以由高频RC振荡器(HFRCO)、高频晶体振荡器(HFXO)甚至上述任何一种低频振荡器驱动。这种分配时钟的灵活性，为系统设计人员提供了使用LE...
温故知新（十）——UART
LEOD的博客
08-12 2227
一般而言，CPU与外部通信有两种通信方式：串行通信和并行通信。根据串行数据的时钟控制方式不同，串行通信可以分为：异步通信和同步通信。
linux下串口非标准波特率的实现
Beluma123的专栏
01-19 8315
转载请注明出处http://blog.csdn.net/beluma123,谢谢! 最近要在linux下使用电脑的串口，而使用的波特率不是诸如9600，19200之类的标准波特率，从网上查找非标准波特率的设置方法，都是说对termios结构体进行设置。按照网上的代码进行设置却不成功。费了很大力气终于找到了原因：原来我的linux版本支持一部分非标准的波特率。下面详细说明 操作系统版本：ub
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值