FPGA串口实现（带FIFO）

看了CrazyBingo的书的前几章，开始写代码实践了。刚好自己手上有一个xilinx的开发板，上面有串口的资源。索性，就来实现这个串口的功能。实现串口的发送和接收。

串口的协议很简单，从网上找了个图说明下：

串口所用的协议时UART协议。UART协议是异步的通信协议。只用一根线完成数据的传输。协议的时序如上图所示：

在空闲状态，即没有数据传输时，线上电平保持为高电平。当开始有数据传输时，线上电平会拉低，表示开始传输数据。第一个数据位开始位，然后是数据位，数据位可以是8位，也可以使8位到4位，但是顺序是低位在前，高位在后。最后是一个高电平的停止位。这样就完成了一次数据传输。

以发送8位数据8’h28(二进制00101000)为例。

则线上的电平依次为 1->0->0->0->0->1->0->1->0->0->1。

由于是异步，没有时钟同步，所以通信的双方要约定好，传输每一位的时间，这个时间就是由波特率来决定的。

波特率是指传输每一位所用的时间，如果采用波特率256000.那么每一位传输的时间为：

1/256000 = 3.9025us。

通信是有发送和接收的，所以串口就有两根线，一根线发送数据，一根线接收数据。

以上就是串口的一些介绍，详细的介绍可以自行百度，可以了解到更多串口的细节。

以下实现一个全双工的串口接收和发送，采用FIFO对接受到的数据进行储存，然后接收外部发送信号，就将FIFO中的接收到的数据，通过串口发送。波特率为256000，数据为8位。

以上是结构图，画的有点挫。接收模块接收外部发送的串口数据，将数据储存到FIFO中，FIFO有外部使能信号（这里是按键按下）,就将FIFO中的数据传给发送模块，发送模块在将数据发送出去。

因为是全双工模式，所以对于发送和接收各有一个波特率产生模块。用来定时数据每一位的时间。以满足串口协议的要求。

对于发送模块：

波特率程序：

module band_generate_tx
#(
parameter baud = 115200 //baud 9600-256000
)
(
input clk,
input rst_n,
input start, //start send data mode
input finish, //send data mode finish
output reg time_arr_tx //baud overflow
);
localparam cnt_16 = 15;
/*********************baud counter value calculate*********************/
reg [7:0] cnt_baud;
//calculate baud counter value
//counter value = 50_000_000 / baud /16 -1;
initial begin
case(baud)
9600 : cnt_baud = 328 -1;
14400 : cnt_baud = 217 -1;
19200 : cnt_baud = 163 -1;
28800 : cnt_baud = 109 -1;
38400 : cnt_baud = 81 -1;
56000 : cnt_baud = 56 -1;
57600 : cnt_baud = 54 -1;
115200: cnt_baud = 27 - 1;
128000: cnt_baud = 24 -1;
256000: cnt_baud = 12 -1;
default :cnt_baud = 12 -1;
endcase
end
/*********************baud counter value calculate*********************/
reg [3:0] count_16;
reg start_flag;
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
start_flag <= 'd0;
else
begin
if(start)
start_flag <= 1;
else if(finish)
start_flag <= 0;
else
start_flag <= start_flag;
end
end
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
begin
count_16 <= 0;
end
else
begin
if(start_flag)
begin
if(count_16 >= cnt_16)
begin
count_16 <= 0;
end
else
begin
count_16 <= count_16 + 1'b1;
end
end
end
end
reg [4:0] count_baud;
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
begin
count_baud <= 0;
time_arr_tx <= 0;
end
else
begin
if(start_flag)
begin
if(count_16 >= cnt_16)
begin
if(count_baud>=cnt_baud)
begin
count_baud <= 'd0;
end
else
count_baud <= count_baud + 1'b1;
if(count_baud == cnt_baud - 1'b1)
time_arr_tx <= 1;
else
time_arr_tx <= 0;
end
else
begin
time_arr_tx <= 0;
end
end
else
begin
count_baud <= 0;
time_arr_tx <= 0;
end
end
end
endmodule

该模块可以实现波特率从9600到256000.只需要例化模块的时候，改变波特率参数值即可。这里采用initial语句来计算产生不同的波特率需要的计数值。因为要产生串口协议波特率规定的定时时间，所以要有一个计数器，来产生这样的一个定时时间。而计数器计数是需要一个计数值的。这里采用initial来计算该计数值。

我们知道initial语句是不可综合的，但是在有些情况下，它又是可以综合的。在计算初始值的时候，是可以综合的。比如这里计算计数器的初始值。或者对寄存器的初始化。

分析一下上面这段程序。这段程序是实现波特率控制的，波特率产生不是什么时候都产生，是需要的时候才产生。在这里，就是要有发送数据的时候，才进行波特率产生。这里的start信号是外部给的串口发送数据信号，但是这样信号只会持续一个时钟周期，而后面的波特率产生是判断这个信号一直使能在进行波特率产生，那这里就有一个问题，怎么把这一个只持续一个时钟周期的信号给扩展为一直持续使能了。这个就是上面代码的功能，将一个只持续一个时钟周期的信号给扩展为一直持续使能。

当start信号有效的时候，start_flag为高，即使能，一个时钟周期后，start信号无效，但是start_flag保持使能。一旦发送数据完成后，finish信号有效到来，将start_flag无效，是关闭波特率产生。

那么问题来了，上述代码会对应怎样的一个数字电路，大家可以去想想。我想的结果是一个除法器加3个门。

波特率产生模块，主要是给发送模块提供一个波特率溢出信号，提示发送模块，该位数据发送完成，准备发下一位数据。

接下来是发送模块。采用状态机设计：

module uart_txd(
//global signal
input clk, //clk 50M
input rst_n, //reset signal, active-low
//input signal
input start, //start uart send mode
input time_arr, //baud overflow signal
input [7:0] data_in, //8-bits data to be send
//output signal
output reg finish, //send mode finish
output reg uart_txd //serial send data
);
//state
localparam idle_state = 4'd0;
localparam start_state = 4'd1;
localparam send_0_state = 4'd2;
localparam send_1_state = 4'd3;
localparam send_2_state = 4'd4;
localparam send_3_state = 4'd5;
localparam send_4_state = 4'd6;
localparam send_5_state = 4'd7;
localparam send_6_state = 4'd8;
localparam send_7_state = 4'd9;
localparam stop_state = 4'd10;
reg [3:0] state;
reg [3:0] state_next;
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
state <= idle_state;
else
state <= state_next;
end
always@(*) begin
state_next = state;
finish = 0;
uart_txd = 0;
case(state)
idle_state: begin //idle state , uart_txd value is hign level.
uart_txd = 1;
if(start)
state_next = start_state;
end
start_state :
begin //send start bit. uart_txd value is 0
uart_txd = 0;
if(time_arr)
begin
state_next = send_0_state;
end
end
send_0_state :
begin
uart_txd = data_in[0];
if(time_arr)
begin
state_next = send_1_state;
end
end
send_1_state :
begin
uart_txd = data_in[1];
if(time_arr)
begin
state_next = send_2_state;
end
end
send_2_state :
begin
uart_txd = data_in[2];
if(time_arr)
begin
state_next = send_3_state;
end
end
send_3_state :
begin
uart_txd = data_in[3];
if(time_arr)
begin
state_next = send_4_state;
end
end
send_4_state :
begin
uart_txd = data_in[4];
if(time_arr)
begin
state_next = send_5_state;
end
end
send_5_state :
begin
uart_txd = data_in[5];
if(time_arr)
begin
state_next = send_6_state;
end
end
send_6_state :
begin
uart_txd = data_in[6];
if(time_arr)
begin
state_next = send_7_state;
end
end
send_7_state :
begin
uart_txd = data_in[7];
if(time_arr)
begin
state_next = stop_state;
end
end
stop_state :
begin
uart_txd = 1;
if(time_arr)
begin
state_next = idle_state;
finish = 1;
end
end
default: state_next = idle_state;
endcase
end
endmodule

代码也很简单，只要有发送使能信号，就启动状态机，发送数据，在每一个波特率溢出信号作用下，进行状态转移，以完成每一位数据的发送。这里，要注意，停止位的数据位一定要为1.这里为什么要为1，后面再解释。

接着，就用一个发送顶层模块将上述两个模块进行封装。

module uart_tx
#(
parameter baud = 256000
)
(
input clk,
input rst_n,
input start,
input [7:0] tx_data,
output uart_txd,
output finish
);
wire time_arr_tx;
band_generate_tx #(.baud(baud))
band_generate_tx_1
(
.clk(clk),
.rst_n(rst_n),
.start(start),
.finish(finish),
.time_arr_tx(time_arr_tx)
);
uart_txd uart_txd_1(
.clk(clk),
.rst_n(rst_n),
.start(start),
.time_arr(time_arr_tx),
.data_in(tx_data),
.finish(finish),
.uart_txd(uart_txd)
);
endmodule

封装的好处，是方面顶层的调用。

接着就是接受数据的模块：

首先是波特率产生：

module band_generate_rx
#(
parameter baud = 115200 //baud 9600-256000
)
(
input clk,
input rst_n,
input start,
input finish,
output reg time_arr_rx
);
localparam cnt_16 = 15;
/*********************baud counter value calculate*********************/
reg [7:0] cnt_baud;
//calculate baud counter value
//counter value = 50_000_000 / baud /16 -1;
initial begin
case(baud)
9600 : cnt_baud = 328 -1;
14400 : cnt_baud = 217 -1;
19200 : cnt_baud = 163 -1;
28800 : cnt_baud = 109 -1;
38400 : cnt_baud = 81 -1;
56000 : cnt_baud = 56 -1;
57600 : cnt_baud = 54 -1;
115200: cnt_baud = 27 - 1;
128000: cnt_baud = 24 -1;
256000: cnt_baud = 12 -1;
default :cnt_baud = 12 -1;
endcase
end
/*********************baud counter value calculate*********************/
reg [3:0] count_16;
reg start_flag;
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
start_flag <= 'd0;
else
begin
if(start)
start_flag <= 1;
else if(finish)
start_flag <= 0;
else
start_flag <= start_flag;
end
end
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
begin
count_16 <= 0;
end
else
begin
if(start_flag)
begin
if(count_16 >= cnt_16)
begin
count_16 <= 0;
end
else
begin
count_16 <= count_16 + 1'b1;
end
end
end
end
reg [4:0] count_baud;
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
begin
count_baud <= 0;
time_arr_rx <= 0;
end
else
begin
if(start_flag)
begin
if(count_16 >= cnt_16)
begin
if(count_baud>=cnt_baud)
begin
count_baud <= 'd0;
end
else
count_baud <= count_baud + 1'b1;
if(count_baud == cnt_baud/2 )
time_arr_rx <= 1;
else
time_arr_rx <= 0;
end
else
begin
time_arr_rx <= 0;
end
end
else
begin
count_baud <= 0;
time_arr_rx <= 0;
end
end
end
endmodule

采用和发送模块的波特率产生模块一样的结构，只是波特率的溢出信号时间不一样。发送的波特率溢出是在波特率时间的末尾，而接受的波特率溢出是在波特率时间的中间。因为在中间采集的数据才是正确有效的。

这里要明白一个东西，因为数据是一位一位传输的，所以数据改变的时间也是要注意的，不能在数据改变的时候接收数据，这样接受的数据就有可能不正确。数据变化是在波特率时间的末尾，所以接收数据要在波特率时间的中间。

下面是接收模块：

module uart_rxd(
//global signal
input clk, //clk signal .50M
input rst_n, //reset signal , active-low
//input signal
input time_arr, //baud overflow signal
input rxd, //rxd input data
output reg [7:0] rxd_data, //receive rxd 8-bits data
output start, //start receive mode
output reg finish //receive mode finish
);
/********************judge rxd falling edge*********************/
reg rxd_r ;
reg rxd_r_r ;
wire rxd_falling ;
always@( posedge clk ) begin
if( !rst_n )
begin
rxd_r <= 'b1 ;
rxd_r_r <= 'b1 ;
end
else
begin
rxd_r <= rxd ;
rxd_r_r <= rxd_r ;
end
end
assign rxd_falling = rxd_r_r & ( !rxd_r ) ;
/********************judge rxd falling edge*********************/
reg [3:0] i;
reg start_flag;
//receive 9-bits data. but the high 8-bits is real data. the last bit is start data
reg [8:0] rxd_data_reg;
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
begin
rxd_data_reg <= 'd0;
i <= 'd0;
end
else
begin
if(start_flag) //receive data
begin
if(time_arr ==1 )
begin
rxd_data_reg <= {rxd,rxd_data_reg[8:1]};
i <= i +4'd1;
end
end
else
begin
rxd_data_reg <= 'd0;
i <='d0;
end
end
end
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
begin
start_flag <= 'b0;
rxd_data <= 'd0;
finish <= 'b0;
end
else
if(rxd_falling)
start_flag <= 1'b1;
else if(i >= 9 && start_flag == 1)
begin
start_flag <= 1'b0;
rxd_data <= rxd_data_reg[8:1];
finish <= 1'b1;
end
else
finish <= 1'b0;
end
//if rxd generate a falling edge,that indicate receive mode start
assign start = rxd_falling;
endmodule

这里没有采用状态机的方式设计，这里可以看出，采用状态机设计，代码便于理解和编写。

封装上述两个模块，成一个接收模块：

module uart_rx
#(
parameter baud = 256000
)
(
input clk,
input rst_n,
input uart_rxd,
output [7:0] receive_data,
output finish
);
wire time_arr_rx;
wire start;
band_generate_rx #(.baud(baud))
band_generate_rx_1 (
.clk(clk),
.rst_n(rst_n),
.start(start),
.finish(finish),
.time_arr_rx(time_arr_rx)
);
uart_rxd uart_rxd_1 (
.clk(clk),
.rst_n(rst_n),
.time_arr(time_arr_rx),
.rxd(uart_rxd),
.rxd_data(receive_data),
.start(start),
.finish(finish)
);
endmodule

然后在用一个串口顶层模块对上面发送和接受模块封装。

module uart_top
#(
parameter baud_tx = 256000,
parameter baud_rx = 256000
)
(
input clk,
input rst_n,
input uart_rxd, //input serial rxd data
input tx_start, //input start send data module signal
input [7:0] tx_data, //input 8-bits send data
output tx_finish, //output send mode finish
output rx_finish, //output receive mode finish
output uart_txd, //output serial txd data
output [7:0] receive_data //output receive 8-bits data
);
//receive module
uart_rx #(.baud(baud_rx))
uart_rx_1 (
.clk(clk),
.rst_n(rst_n),
.uart_rxd(uart_rxd),
.receive_data(receive_data),
.finish(rx_finish)
);
//send module
//when tx_start is 1, send module will send 8-bit input tx_data to the serial txd
uart_tx #(.baud(baud_tx))
uart_tx_1 (
.clk(clk),
.rst_n(rst_n),
.start(tx_start),
.tx_data(tx_data),
.uart_txd(uart_txd),
.finish(tx_finish)
);
endmodule

这样，就完成了整个的串口设计模块了。

剩下的就是FIFO模块了，这里是调用xilinx的FIFO IP核。直接拿来使用，位宽8位，深度4096.意思可以存储4096个外部发送的字节数据。

module test_uart_fifo(
input clk,
input rst_n,
input key,
input rx_finish,
input [7:0] rx_data,
input tx_finish,
//input start,
output reg tx_start,
output [7:0] tx_data
);
//wire start;
//wire full;
wire empty;
reg rd_en;
key_button key_button_1 (
.clk(clk),
.rst_n(rst_n),
.key(key),
.key_down(start)
);
fifo_uart fifo_uart_1 (
.clk(clk), // input clk
.rst(rst_n), // input rst
.din(rx_data), // input [7 : 0] din
.wr_en(rx_finish), // input wr_en
.rd_en(rd_en), // input rd_en
.dout(tx_data), // output [7 : 0] dout
.full(), // output full
.empty(empty) // output empty
);
localparam idle_state = 0;
localparam send_state = 1;
reg start_flag;
reg state;
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
begin
state <= idle_state;
tx_start <= 0;
rd_en <= 0;
end
else
begin
case(state)
idle_state:
begin
if(start_flag)
begin
tx_start <= 1;
state <= send_state;
rd_en <= 1;
end
else
begin
tx_start <= 0;
state <= idle_state;
rd_en <= 0;
end
end
send_state:
begin
tx_start <= 0;
rd_en <= 0;
if(tx_finish)
state <= idle_state;
end
endcase
end
end
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
start_flag <= 0;
else
begin
if(start)
start_flag <= 1;
else if(empty)
start_flag <= 0;
end
end
endmodule

其中key_button模块，是检测按键下降沿的。我这里是设定我按下按键，就将FIFO的所有数据发送出去。而fifo_uart模块，是例化FIFO的IP。

最终的顶层代码：

module test_uart(
input clk,
input rst_n,
input uart_rxd,
input key,
//input start,
output uart_txd,
output [7:0] LED
);
wire tx_start;
wire rx_finish;
wire tx_finish;
wire [7:0] tx_data;
wire [7:0] receive_data;
uart_top #(.baud_tx(256000),
.baud_rx(256000))
uart_top_1 (
.clk(clk),
.rst_n(rst_n),
.uart_rxd(uart_rxd),
.tx_start(tx_start),
.tx_data(tx_data),
.tx_finish(tx_finish),
.rx_finish(rx_finish),
.uart_txd(uart_txd),
.receive_data(receive_data)
);
test_uart_fifo test_uart_fifo_1 (
.clk(clk),
.rst_n(rst_n),
.key(key),
//.start(start),
.rx_finish(rx_finish),
.rx_data(receive_data),
.tx_finish(tx_finish),
.tx_start(tx_start),
.tx_data(tx_data)
);
assign LED = ~receive_data;
endmodule

代码也很简单，就将两个模块连接起来。

综合，分配管脚，然后布局布线，最后下载。使用串口猎人，用来发送数据和接收数据。

串口测试成功了。

最终效果如下，很酷吧。。发送的数据是Crazybingo写的书的自序的一部分。

发送数据后，按下开发板按键，就将发送的数据发回。使用串口猎人捕获，即可得到数据。

在实现这个功能时候，有遇到一下问题：

发送单个数据，接收单个数据正确，但是发送一串数据，接收就只能接受到最后一个数据，而不是发送的一串数据。

这个问题，我可折腾了好久。最开始以为是FIFO没有正常工作，写testbench仿真，发现还真的是有这个问题。FIFO的复位信号弄反了。这个系统是设定的低电平复位，而FIFO设定的高电平复位，所以接收数据不对。将复位信号更正后，发现还是有问题。在仿真FIFO，发现FIFO是正常工作的。那出现的问题，肯定就是我的串口模块的问题。

各种写testbench代码仿真，仿真后，发现，接收模块是没有问题的，那问题就应该是发送模块的问题。通过仿真，发现发送的时序是对的，确实将每个数据按照规定的时序发送出去。但是发现发完一个数据后，只隔了一个系统时钟周期，就马上发送第二个数据。这里，就猜想，是不是数据发送太快，数据发送完，要在等一个波特率时间在发送下一个数据。百度下，发现，原来，发送的停止位的数据是要为1的。而我写程序的时候，以为停止位是0或1都没有关系，就给了个0.将这里改正，发现，程序对了。能实现发一串数据，然后FPGA在回发一串数据了。

所以要注意，发送的时候，停止位的数据一定要为高电平！！！！！！！！！！！！！！！！