FPGA串口通信----uart（二）

最新推荐文章于 2024-08-09 22:00:08 发布
最新推荐文章于 2024-08-09 22:00:08 发布
阅读量143 收藏 4
点赞数 9
文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mvpkuku/article/details/140933537
版权

在UART（一）中主要解决的是单字节的发送和接受，但是单字节的应用场景相对较小。在大多数场景下，串口都是用于连续多字节的收发工作。 因此，本篇文章将基于已有的单字节串口收发模块，结合上一章学习的状态机，完成多字节串口发送模块和多字节串口接收模块的设计，并通过仿真和板级测试对设计进行验证,完成多字节串口收发的验证。

一、多字节发送（Tx_bytes）

1.1Verilog 代码： 

例化UART(一）的单字节发送模块 

`timescale 1ns / 1ps
//
// Description: 串口多字节发送
//
module uart_bytes_tx#(
    parameter  DATA_WIDTH = 32
)(
    Clk			,
	Rst_n		,
	data_bytes	,
	send_en		,   
	Baud_Set	,  
	uart_tx		,  
	Tx_Done		,   
	uart_state 
);
	input 		                Clk 		;    //模块全局时钟输入，50M
	input 		                Rst_n		;    //复位信号输入，低有效
	input [DATA_WIDTH - 1:0]    data_bytes	;    //待传输 多字节 数据
	input 		                send_en		;    //发送使能
	input [2:0]	                Baud_Set	;    //波特率设置
	output  	                uart_tx		;    //串口输出信号
	output reg 	                Tx_Done		;    //数据发送完成标志
	output  	                uart_state	;    //发送数据状态

reg [3:0]               state,n_state   ;
reg [7:0]               cnt             ;
reg [DATA_WIDTH - 1:0]  r_data_bytes    ;
reg [7:0]               data_byte       ;
reg                     send_byte_en    ;
wire                    byte_tx_done    ;
wire                    uart_tx         ;
wire                    uart_state      ;
//**********  单字节数据发送模块例化 *******\\
uart_tx_byte uart_tx_byte_u0(
    .Clk			(Clk         ),
	.Rst_n		    (Rst_n       ),  
	.data_byte	    (data_byte   ),
	.send_en		(send_byte_en),   
	.Baud_Set	    (Baud_Set    ),  	
	.uart_tx		(uart_tx     ),  
	.Tx_Done		(byte_tx_done),   
	.uart_state     (uart_state  )
);

localparam  S0 = 4'b0001, //等待发送使能(初始态)
            S1 = 4'b0010, //准备数据
            S2 = 4'b0100, //等待单字节数据发送完成
            S3 = 4'b1000; //检查所有数据是否发送完成
//**************  状态机  ***************\\
always @(posedge Clk or negedge Rst_n) begin
    if(!Rst_n)
        state <= S0;
    else 
        state <= n_state;
end

always @(*) begin
    case (state)
        S0: if(send_en)
                n_state <= S1;
            else 
                n_state <= S0;
        S1: n_state <= S2;
        S2: if(byte_tx_done)
                n_state <= S3;
            else
                n_state <= S2;
        S3: if(cnt >= DATA_WIDTH - 8)
                n_state <= S0;
            else
                n_state <= S1;
        default:n_state <= S0;
    endcase
end

always @(posedge Clk or negedge Rst_n) begin
    if(!Rst_n)
        r_data_bytes <= 'd0;
    else if(state == S0 && send_en)
        r_data_bytes <= data_bytes;
    else if(state == S1)
        r_data_bytes <= r_data_bytes << 8;
    else 
        r_data_bytes <= r_data_bytes;
end

always @(posedge Clk or negedge Rst_n) begin
    if(!Rst_n)
        send_byte_en <= 'd0;
    else if(state == S1)
        send_byte_en <= 'd1;
    else
        send_byte_en <= 'd0;
end

always @(posedge Clk or negedge Rst_n) begin
    if(!Rst_n)
        data_byte <= 'd0;
    else if(state == S1)
        data_byte <= r_data_bytes[DATA_WIDTH - 1 : DATA_WIDTH  -8];
    else
        data_byte <= data_byte;
end

always @(posedge Clk or negedge Rst_n) begin
    if(!Rst_n)
        cnt <= 'd0;
    else if(state == S3 && cnt >= DATA_WIDTH - 8)
        cnt <= 'd0;
    else if(state == S3)
        cnt <= cnt + 'd8;
    else
        cnt <= cnt;
end

always @(posedge Clk or negedge Rst_n) begin
    if(!Rst_n)
        Tx_Done <= 'd0;
    else if(state == S3 && cnt >= DATA_WIDTH - 8)
        Tx_Done <= 'd1;
    else
        Tx_Done <= 'd0;
end

endmodule

1.2 tb文件 

`timescale 1ns / 1ps
module tb_byte_tx();

parameter DATA_WIDTH = 32;
    reg 		                Clk 		;    //模块全局时钟输入，50M
	reg 		                Rst_n		;    //复位信号输入，低有效
	reg [DATA_WIDTH - 1:0]      data_bytes	;    //待传输 多字节 数据
	reg 		                send_en		;    //发送使能
	wire	                    uart_tx		;    //串口输出信号
	wire	                    Tx_Done		;    //1byte数据发送完成标志
	wire	                    uart_state	;    //发送数据状态

uart_bytes_tx#(
    .DATA_WIDTH     (DATA_WIDTH )
)
uart_bytes_tx_u0
(
    .Clk			(Clk 		),
	.Rst_n		    (Rst_n		),
	.data_bytes	    (data_bytes	),
	.send_en		(send_en	),   
	.Baud_Set	    ('d4     	),  	
	.uart_tx		(uart_tx	),  
	.Tx_Done		(Tx_Done	),   
	.uart_state     (uart_state	)
);
initial Clk = 0;
always #10 Clk = ~Clk;

initial begin
    Rst_n = 0;
    data_bytes = 0;
    send_en = 0;
    #201;
    Rst_n = 1;
    #2000;
    data_bytes = 32'h01234567;
    send_en = 1;
    #20;
    send_en = 0;
    #20;
    @(posedge Tx_Done);
    #1;
    data_bytes = 32'h12345678;
    send_en = 1;
    #20;
    send_en = 0;
    #20;
    @(posedge Tx_Done);
    #1; 
    data_bytes = 32'h23456789;
    send_en = 1;
    #20;
    send_en = 0;
    #20;
    @(posedge Tx_Done);
    #1;
    #2000;
    $stop; 
end
endmodule

仿真图

二、多字节接收 （Rx_bytes）

2.1Verilog 代码 

`timescale 1ns / 1ps
// 
// Description: 多字节接收
//
module uart_bytes_rx#(
    parameter  DATA_WIDTH = 32
)(
    Clk             ,
    Rst_n           ,
    uart_rx         ,
    Baud_Set        ,
    Rx_done         ,
    timeout_flag    ,
    rx_data_bytes
    );
input                           Clk             ;
input                           Rst_n           ;
input                           uart_rx         ;
input[2:0]                      Baud_Set        ;
output reg                      Rx_done         ;
output reg                      timeout_flag    ;
output reg [DATA_WIDTH - 1 : 0] rx_data_bytes   ;

reg  [DATA_WIDTH - 1 : 0]       r_r_data_bytes  ;

wire [19:0]                     TIMEOUT         ;
wire [7:0]                      data_byte       ;
wire                            byte_rx_done    ;

reg                     to_state        ;
reg[31:0]               timeout_cnt     ;
reg[1:0]                state           ;
reg[8:0]                cnt             ;

//根据波特率自动设置超时时间
assign TIMEOUT  =   (Baud_Set == 3'd0) ? 20'd182291:
                    (Baud_Set == 3'd1) ? 20'd91145 :
                    (Baud_Set == 3'd2) ? 20'd45572 :
                    (Baud_Set == 3'd3) ? 20'd30381 :
                                         20'd15190 ;
	
localparam S0 = 0; //等待单字节接收完成信号
localparam S1 = 1; //判断接收是否超时
localparam S2 = 2; //检查所有数据是否接收完成

//**************** 单字节接收模块例化 ******************\\
uart_byte_rx uart_byte_rx_u0(
    .Clk      (Clk          ),
    .Reset_n  (Rst_n        ),
    .Baud_Set (Baud_Set     ),
    .uart_rx  (uart_rx      ),
    .Data     (data_byte    ),
    .Rx_Done  (byte_rx_done )
);
//****************超时标志 ******************\\
always @(posedge Clk or negedge Rst_n) begin
    if(!Rst_n)
        timeout_flag <= 'd0;
    else if(timeout_cnt >= TIMEOUT)
        timeout_flag <= 'd1;
    else if(state == S0)
        timeout_flag <= 'd0;
    else
        timeout_flag <= timeout_flag;
end

always @(posedge Clk or negedge Rst_n) begin
    if(!Rst_n)
        to_state <= 'd0;
    else if(!uart_rx)
        to_state <= 'd1;
    else if(byte_rx_done)
        to_state <= 'd0;
    else 
        to_state <= to_state;
end

always @(posedge Clk or negedge Rst_n) begin
    if(!Rst_n)
        timeout_cnt <= 'd0;
    else if(to_state)begin
        if(byte_rx_done)
            timeout_cnt <= 'd0;
        else if(timeout_cnt >= TIMEOUT)
            timeout_cnt <= TIMEOUT;
        else
            timeout_cnt <= timeout_cnt + 1;
    end
    else
        timeout_cnt <= timeout_cnt;
end
//**************** 状态机 ******************\\
always @(posedge Clk or negedge Rst_n) begin
    if(!Rst_n)begin
        state           <= S0;
		r_r_data_bytes  <= 0 ;
		cnt             <= 0 ;
		rx_data_bytes   <= 0 ;
	end
	else begin
		case(state)
			S0: 
				begin
					Rx_done <= 0;
					r_r_data_bytes <= 0;
					if(DATA_WIDTH == 8)begin
						rx_data_bytes <= data_byte;
						Rx_done       <= byte_rx_done;
					end
					else if(byte_rx_done)begin
						state <= S1;
						cnt   <= cnt + 9'd8;
					    r_r_data_bytes <= {r_r_data_bytes[DATA_WIDTH - 1 - 8 : 0], data_byte};
					end
				end
			
			S1:
				if(timeout_flag)begin
					state   <= S0;
					Rx_done <= 1 ;	
				end
				else if(byte_rx_done)begin
					state <= S2;
					cnt   <= cnt + 9'd8;
					r_r_data_bytes <= {r_r_data_bytes[DATA_WIDTH - 1 - 8 : 0], data_byte};
				end
				
			S2:
				if(cnt >= DATA_WIDTH)begin
					state <= S0;
					cnt   <= 0;
					rx_data_bytes  <= r_r_data_bytes;
					Rx_done        <= 1;
				end
				else begin
					state   <= S1;
					Rx_done <= 0;
				end
			default:state <= S0;
		endcase	
	end
end
endmodule

2.2 TB文件

`timescale 1ns / 1ps
module uart_rx_bytes_tb();
parameter  DATA_WIDTH = 32;
reg                         Clk     ;
reg                         Rst_n   ;
reg  [DATA_WIDTH - 1 : 0]   data    ;
wire [DATA_WIDTH - 1 : 0]   rx_data ;
reg                         send_en ;
wire                        uart_tx ;
wire                        uart_rx ;
wire                        Tx_Done ;
wire                        uart_state;
wire                        Rx_Done ;
wire                        timeout_flag;

assign uart_rx = uart_tx;

uart_bytes_tx#(
    .DATA_WIDTH     (DATA_WIDTH)
)
uart_bytes_tx_u0
(
    .Clk			(Clk    ),
	.Rst_n		    (Rst_n  ),
	.data_bytes	    (data   ),
	.send_en		(send_en),   
	.Baud_Set	    ('d4    ),  
	.uart_tx		(uart_tx),  
	.Tx_Done		(Tx_Done),   
	.uart_state     (uart_state)
);

uart_bytes_rx#(
    .DATA_WIDTH    (DATA_WIDTH)
)
uart_bytes_rx_u0
(
    .Clk            (Clk    ),
    .Rst_n          (Rst_n  ),
    .uart_rx        (uart_tx),
    .Baud_Set       ('d4    ),
    .Rx_done        (Rx_Done),
    .timeout_flag   (timeout_flag),
    .rx_data_bytes  (rx_data)
);

initial Clk = 1;
always #10 Clk = !Clk;

initial begin
    Rst_n = 0;
    data = 0;
    send_en = 0;
    #201;
    Rst_n = 1;
    #2000;
    data = 32'h12345678;
    send_en = 1;
    #20;
    send_en = 0;
    #20;
    @(posedge Tx_Done);
    #1;
    #1000000;
    data = 32'h87654321;
    send_en = 1;
    #20;
    send_en = 0;
    #20;
    @(posedge Tx_Done);
    #1; 
    #1000000;
    data = 32'h24680135;
    send_en = 1;
    #20;
    send_en = 0;
    #20;
    @(posedge Tx_Done);
    #1;
    #400000;
    $stop; 
end

endmodule

 仿真图

三、多字节串口收发回环 （loopback）

3.1Verilog 代码

`timescale 1ns / 1ps
//
// Description: 串口回环
//
module uart_loopback#(
    parameter  DATA_WIDTH = 32
)
(
    Clk     ,
    Rst_n   ,
    uart_rx ,
    led     ,
    uart_tx 
);



input                   Clk         ;
input                   Rst_n       ;
input                   uart_rx     ;

output [2:0]            led         ;
output                  uart_tx     ;

wire [DATA_WIDTH-1:0]   data        ;
wire                    Rx_Done     ;
wire [7:0]              data_byte   ;

uart_bytes_rx#(
    .DATA_WIDTH   (DATA_WIDTH)
)
uart_bytes_rx_u0
(
    .Clk             (Clk    ),
    .Rst_n           (Rst_n  ),
    .uart_rx         (uart_rx),
    .Baud_Set        ('d4    ),
    .Rx_done         (Rx_Done),
    .timeout_flag    (led[0]),
    .rx_data_bytes   (data  )   
    );
uart_bytes_tx#(
    .DATA_WIDTH   (DATA_WIDTH)
)
uart_bytes_tx_u0
(
    .Clk			(Clk    ),
	.Rst_n		    (Rst_n  ),
	.data_bytes	    (data   ),
	.send_en		(Rx_Done),   
	.Baud_Set	    ('d4    ),  
	.uart_tx		(uart_tx),  
	.Tx_Done		(led[1]),   
	.uart_state     (led[2])
);
endmodule

 3.2 TB文件（例化多字节发送数据来发模拟数据）

`timescale 1ns / 1ps
module uart_loopback_tb();
parameter  DATA_WIDTH = 256;

reg                   Clk         ;
reg                   Rst_n       ;

wire                  uart_rx     ;
wire [2:0]            led         ;
wire                  uart_tx     ;

reg [DATA_WIDTH-1:0]    data        ;
reg                     send_en     ;
wire                    TX_Done     ;
wire                    uart_state   ;
wire                    uart_tx_u0  ;

assign uart_rx = uart_tx_u0;
uart_bytes_tx#(
    .DATA_WIDTH (DATA_WIDTH)
)
uart_bytes_tx_u0
(
    .Clk			(Clk    ),
	.Rst_n		    (Rst_n  ),
	.data_bytes	    (data   ),
	.send_en		(send_en),   
	.Baud_Set	    ('d4    ),  
	.uart_tx		(uart_tx_u0),  
	.Tx_Done		(TX_Done),   
	.uart_state     (uart_state)
);
uart_loopback #(
    .DATA_WIDTH (DATA_WIDTH)
)
uart_loopback_u0
(
    .Clk     (Clk     ),
    .Rst_n   (Rst_n   ),
    .uart_rx (uart_rx ),
    .led     (led     ),
    .uart_tx (uart_tx )
);

initial Clk = 1;
	always #10 Clk = !Clk;
	
	initial begin
		Rst_n = 0;
		data = 0;
		send_en = 0;
		#201;
		Rst_n = 1;
		#2000;
		data = 256'h890abcdef12312345abcdef674567890cba0987654fed365432121fedcba0987;
		send_en = 1;
		#20;
		send_en = 0;
		#20;
		@(posedge TX_Done);
//        #1;
		#1000000;
		data = 256'hcba0987654fed365432121fedcba0987ba09876fe321dc54b321dc6fe54a0978;
		send_en = 1;
		#20;
		send_en = 0;
		#20;
		@(posedge TX_Done);
//		#1;	
		#1000000;
		data = 256'h890abcdef123123454fed365432121fedcba09875abcdef674567890cba09876;
		send_en = 1;
		#20;
		send_en = 0;
		#20;
		@(posedge TX_Done);
		#1;
		#4000000;
		$stop;		
	end
endmodule

仿真图 

 上板仿真

可以成功实现 

 

MVP-curry-萌神
关注
  • 9
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FPGA实现串口（UART）
孤独的单刀
03-10 26万+
通过本文您会学到：1、什么是UART？2、如何用FPGA实现它？
FPGA串口通信----uart（一）
mvpkuku的博客
08-05 315
通过PLL锁相环IP的使用，可以输入时钟进行分频，倍频，也可以产生多路时钟输出信号。外部提供晶振的原因:①Fpga电路大多数需要时序分析②晶振在Fpga内部占空间大，所以放置于外部PCB板上Uart异步传输速率不能很快的原因：考虑到工程实际问题，假如时钟周期大（传输速率慢的话），采取到数据电平变化的边沿时刻的概率会小很多，这样数据也很准确，通常uart适用于2M.
FPGA-UART(串口通信)
j98022154的博客
07-22 464
FPGA-UART串口调试
FPGA-UART串口通信
qq_45268949的博客
05-10 1872
FPGA-UART串口通信
【FPGA】UART串口通信---基于FIFO
热门推荐
wanerXR的博客
06-04 1万+
我们在上一章完成了UART串口通信的收发模块，这一章我们将FIFO引入进来，使用FIFO进行缓存数据，来连接串口通信的收发模块同步FIFO 读和写应用同一个时钟。它的作用一般是做交互数据的一个缓冲，也就是说它的主要作用就是一个buffer1。异步FIFO 读写应用不同的时钟，它有两个主要的作用，一个是实现数据在不同时钟域进行传递，另一个作用就是实现不同数据宽度的数据接口。同步FIFO和异步FIFO略有不同，下面的参数适用于两者。，用参数FIFO_data_size表示，也就是FIFO存储的数据宽度； ，用参
FPGA-UART-全双工串行通信
qq_46303613的博客
03-24 2195
FPGA-停车场计数器 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录FPGA-停车场计数器前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文
串行通信接口-UART
余生芳华，灵魂共舞
10-17 3740
介绍常见的传统串行通信接口，UART通信协议内容，提供FPGA源码.
FPGA-UART串口
博客
01-17 1869
UART:全称为Universal Asynchronous Receiver/Transmitter,通用异步收发器。是一种串行异步的通信协议,该协议规定了传输数据时数据的传输方式以及所使用的信号,在嵌入式领域中有着非常广泛的应用。通用异步收发传输器（Universal Asynchronous Receiver/Transmitter，UART）是一种异步 收发传输器，其在数据发送时将并行数据转换成串行数据来传输，在数据接收时将接收到的 串行数据转换成并行数据，可以实现全双工传输和接收。
FPGA--UART串口通信
weixin_60354142的博客
03-09 1005
串口是“串行接口”的简称，即采用串行通信方式的接口。串行通信将数据字节分成一位一位的形式 在一条数据线上逐个传送，其特点是通信线路简单，但传输速度较慢。因此串口广泛应用于嵌入式、工业 控制等领域中对数据传输速度要求不高的场合。 串行通信分为两种方式：同步串行通信和异步串行通信。同步串行通信需要通信双方在同一时钟的控 制下，同步传输数据；异步串行通信是指通信双方使用各自的时钟控制数据的发送和接收过程。 UART 是一种采用异步串行通信方式的通用异步收发传输器（universal asynchronous
fpga-uart.zip_FPGA串口通信
09-14
**FPGA串口通信详解** 在电子工程领域，FPGA（Field-Programmable Gate Array）因其可编程性被广泛应用于各种系统设计中，其中包括与外部设备进行数据交互的串行通信。本实验以"FPGA-UART.zip"为主题，旨在探讨如何...
基于FPGA的AXI-lite接口 UART设计
03-13
UART是一种常见的串行通信接口，广泛用于设备间的低速通信。它通过一对数据线（TX和RX）进行数据传输，通常用于调试、打印输出或者连接不同系统之间的简单通信。在FPGA设计中，UART模块可以实现与外部世界的串行通信...
FPGA基础入门－开发板USB-UART串口通信配置工程文件
08-19
与教程--FPGA基础入门【11】开发板USB-UART串口通信配置--相应的源代码。 根目录包含： 1. 相关文档，nexys4ddr_rm.pdf是开发板文档；DS_FT2232H.pdf是UART芯片FT2232HQ文档 2. src/包含所有源代码 3. sim/包含...
FPGA实现的串口通信-综合文档
05-22
串口通信是一种常见的数据传输方式，如UART（通用异步收发传输器）、SPI（串行外围接口）和I2C（集成电路间通信）等。在FPGA中实现串口通信，可以灵活地配置波特率、数据位、停止位和校验位，满足不同设备间的通信...
可编程逻辑设计原则
最新发布
m0_66619666的博客
08-09 890
面积指FPGA逻辑器件的逻辑资源。在逻辑器件资源有限，设计规模庞大的情况下，必须采用牺牲速度以减少资源消耗，节约面积。例如，减少实例化模块数量，分时复用模块。以上是用一个查找表ROM模块在7个周期内实现4组十六进制数转换为十进制数的程序，下面是在4个周期内实现4组十六进制数转换为十进制数的程序。
FPGA开发——IP核的FIFO调用
weixin_63553972的博客
08-09 1180
FIFO 的英文全称是 First In First Out，即先进先出。FPGA 使用的 FIFO 一般指的是对数据的存储具有先进先出特性的一个缓存器，常被用于数据的缓存或者高速异步数据的交互，也即所谓的跨时钟域信号传递。它与 FPGA 内部的 RAM 和 ROM 的区别是没有外部读写地址线，采取顺序写入数据，顺序读出数据的方式，使用起来简单方便，由此带来的缺点就是不能像 RAM 和 ROM 那样可以由地址线决定读取或写入某个指定的地址。
FPGA设计之跨时钟域（CDC）设计篇（5）----同步FIFO的两种设计方法（计数器法/高位扩展法 | 手撕代码）
孤独的单刀
08-05 1364
FPGA设计之跨时钟域（CDC）设计篇（5）----同步FIFO的两种设计方法（计数器法/高位扩展法 | 手撕代码）
FPGA常见型号
qq_53529450的博客
08-09 581
FPGA（现场可编程门阵列）开发板种类繁多，涵盖了从入门级教育用途到高性能工业应用的广泛领域。本文介绍一些常见的 FPGA 开发板型号及其特点。
Nexys 3 FPGA开发板：Spartan-6技术详解
5. **USB-UART端口**：方便地将FPGA与PC或其他设备通过USB进行串行通信，用于调试和数据传输。 6. **USB主机端口**：可以直接连接鼠标和键盘，增强了开发板作为嵌入式系统的实用性。 7. **高速扩展连接器**：这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值