基于Verilog-HDL语言的串口设计.doc

基于Verilog HDL语言的串口设计
串口Verilog HDL代码：
//串口
module trans(clk,rst，en,TxD_data，Wsec，RxD，TxD，TxD_busy,rcven，RxD_data）；//时钟50MHz
input clk,rst，en； //en时发送数据使能
input [7：0］TxD_data; //发送数据输入
input ［2:0］Wsec; //波特率调节0-2400；1—4800；2-9600；3—14400；4—19200；5—38400;6—115200；7-128000
input RxD; //接收数据输入端
output TxD,TxD_busy，rcven;//发送，发送忙，接收结束标志输出
output [7:0］RxD_data;//接收数据输出
wire Baud1,Baud8；
reg ［7：0]addwire；//RAM地址连线
reg ［7:0］data;
wire[7：0］AD_t；//读取RAM数据的地址用于发送
wire［7：0]AD_r；//接收的数据存储在RAM中的地址
wire [7:0］datawire;//数据连线
//发送例化
trans_t tt1(。clk_t(clk）,。rst_t(rst),.en_t(en）,。BTI_t（Baud1)，。recen(recen）,
。TxD_data_t(datawire)，.TxD_t（TxD）,。addro_t(AD_t)，.TxD_busy_t(TxD_busy));
//波特生成例化
BaudG tt2（.clk_b（clk），。rst_b(rst),。BTO_b(Baud1），。BTO_R（Baud8),.Wsec_b（Wsec)）；
//接收例化
trans_r tt3（.clk_r（clk)，。rst_r（rst)，。BTI_r（Baud8），。RxD_r(RxD),
。RxD_data_r(RxD_data）,.wren_r（wren_r），。addro_r（AD_r）,。RxD_end（RxD_end）)；
//LPM_RAM例化
RAM0 tt4(。address（addwire），。clock（～clk),.data（data），。wren(wren_r)，。q（datawire)）;
always ＠（posedge clk or negedge rst）
if(～rst）
addwire 〈= 8'b00000000;
else if(RxD_end）
begin
addwire 〈=AD_r ；data<=RxD_data；
end
else addwire<=AD_t；
endmodule
//发送模块
module trans_t（clk_t，rst_t,en_t，BTI_t，TxD_data_t，TxD_t，recen,TxD_busy_t,addro_t，recen ）；
input clk_t,rst_t，en_t，BTI_t；
input ［7：0]TxD_data_t;
output TxD_t;
output TxD_busy_t；
output recen；
output ［7：0］addro_t；
reg TxD_t；
reg [7：0］TxD_dataReg；//寄存器
reg ［7：0］addro_t;//
reg ［3：0］state；
reg recen;
wire TxD_busy_t；
assign BaudTick = BTI_t;//波特输出
// 发送启动
wire TxD_ready = （state==0); // TxD_ready = 1
assign TxD_busy_t = ～TxD_ready；
// 加载发送数据
always ＠（posedge clk_t or negedge rst_t)
if(～rst_t)
TxD_dataReg <= 8’b00000000；
else if（TxD_ready ＆& en_t)
TxD_dataReg 〈= TxD_data_t；
// 状态机发送
always @（posedge clk_t or negedge rst_t）
if（～rst_t）
begin
state <= 4’b0000; // 复位时发送1
TxD_t <= 1’b1；
end
else
case（state)
4’b0000： if(en_t ） begin
state 〈= 4’b0100; // 检测发送开始
end
4’b0100: if（BaudTick &＆ en_t） begin
state 〈= 4’b1000； // 发送起始位0
TxD_t 〈= 1’b0；
end
4’b1000： if(BaudTick && en_t） begin
state <= 4’b1001； // bit 0
if（en_t) TxD_t <= TxD_dataReg[0］；
else TxD_t <= 1’b0;
end
4'b1001: if(BaudTick ＆＆ en_t） begin
state 〈= 4’b1010; // bit 1
if（en_t） TxD_t 〈= TxD_dataReg［1］；
else TxD_t <= 1’b0;
end
4'b1010: if（BaudTick && en_t） begin
state <= 4’b1011; // bit 2
if(en_t） TxD_t 〈= TxD_dataReg［2］;
else TxD_t 〈= 1’b0；
end
4'b1011： if(BaudTick && en_t） begin
state <= 4'b1100; // bit 3
if（en_t) TxD_t <= TxD_dataReg［3]；
else TxD_t 〈= 1’b0；
end
4’b1100: if(BaudTick ＆＆ en_t) begin
state <= 4’b1101； // bit 4
if（en_t） TxD_t <= TxD_dataReg［4］;
else TxD_t 〈= 1’b0；
end
4’b1101： if（BaudTick ＆＆ en_t） begin
state 〈= 4’b1110; // bit 5
if(en_t） TxD_t 〈= TxD_dataReg[5];
else TxD_t <= 1’b0;
end
4’b1110： if(BaudTick ＆＆ en_t) begin
state 〈= 4’b1111； // bit 6
if(en_t） TxD_t <= TxD_dataReg［6]；
else TxD_t 〈= 1'b0；
end
4’b1111： if（BaudTick &＆ en_t） begin
state 〈= 4’b0010； // bit 7
if(en_t） TxD_t 〈= TxD_dataReg[7]；
else TxD_t <= 1’b0;
end
4'b0010: if（BaudTick &＆ en_t) begin
state 〈= 4’b0011； // stop1
TxD_t 〈= 1’b1；
end
4'b0011： if（BaudTick) begin
state 〈= 4’b0000； // stop2
TxD_t <= 1’b1；
end
default: if(BaudTick） begin
state 〈= 4’b0000；
TxD_t 〈= 1’b1;
end
endcase
always @（posedge clk_t or negedge rst_t）
if（~rst_t）
begin recen〈=0；end
else if（~TxD_ready）recen<=1;
else recen〈=0；
//地址计数器ddress
always ＠（posedge clk_t or negedge rst_t)
if(～rst_t）
addro_t 〈= 8'b00000000;
else if(TxD_ready &＆ en_t)
addro_t 〈=addro_t +1；
endmodule
//波特生成模块
module BaudG（clk_b，rst_b，BTO_b，BTO_R，Wsec_b)；
input clk_b，rst_b；
input [2：0]Wsec_b;
output BTO_b，BTO_R；
reg FT，FT8；
reg ［16：0］BGA;
reg [16：0]BGA1；
wire BTO_b = FT； //发送波特
wire BTO_R = FT8；//接收模块波特=发送*16
always @(posedge clk_b or negedge rst_b ）
if（~rst_b）
begin BGA 〈= 0;BGA1 <= 0;end
else
case（Wsec_b）
0：begin
if（BGA1>1302）begin FT8=1’b1； BGA1〈=0； end //接收波特=2400＊16
else begin FT8=1’b0； BGA1 〈= BGA1+ 1； end
if（BGA〉62500)begin FT=1’b1；FT8=1’b1; BGA1〈=0； BGA<=0; end //发送波特=2400
else begin FT=1’b0； BGA <= BGA+ 3; end
end
1： begin if（BGA1>651）begin FT8=1'b1； BGA1〈=0； end //接收波特=4800＊16
else begin FT8=1’b0； BGA1 〈= BGA1+ 1; end
if(BGA〉62500)begin FT=1’b1； FT8=1’b1； BGA1〈=0;BGA<=0; end //发送波特=4800
else begin FT=1’b0； BGA 〈= BGA+ 6； end
end
2： begin if（BGA1〉651)begin FT8=1’b1； BGA1<=0； end //接收波特=9600＊16
else begin FT8=1’b0; BGA1〈= BGA1+ 2; end
if（BGA〉15625）begin FT=1'b1;FT8=1’b1; BGA1<=0; BGA〈=0； end //发送波特=9600
else begin FT=1’b0； BGA 〈= BGA+ 3; end
end
3: begin if(BGA1>217）begin FT8=1’b1； BGA1<=0； end //接收波特=14400＊16
else begin FT8=1'b0； BGA1 〈= BGA1+ 1；end
if(BGA〉17361)begin FT=1'b1;FT8=1'b1； BGA1<=0; BGA〈=0; end //发送波特=14400
else begin FT=1'b0; BGA <= BGA+ 5； end
end
4： begin if（BGA1〉651）begin FT8=1’b1； BGA1〈=0； end //接收波特=19200＊16
else begin FT8=1’b0； BGA1 〈= BGA1+ 4；end
if（BGA〉15625）begin FT=1’b1； FT8=1’b1； BGA1<=0;BGA<=0; end //发送波特=19200
else begin FT=1’b0； BGA 〈= BGA+ 6；end
end
5： begin if（BGA1〉244）begin FT8=1’b1; BGA1<=0； end //接收波特=38400＊16
else begin FT8=1’b0； BGA1 〈= BGA1+ 3；end
if(BGA〉15625）begin FT=1'b1；FT8=1’b1; BGA1<=0； BGA<=0; end //发送波特=38400
else begin FT=1'b0; BGA <= BGA+ 12；end
end
6： begin if（BGA1>217）begin FT8=1'b1； BGA1〈=0； end //接收波特=115200＊16
else begin FT8=1’b0； BGA1 〈= BGA1+ 8；end
if（BGA〉434） begin FT=1’b1;FT8=1’b1； BGA1〈=0； BGA〈=0； end //发送波特=115200
else begin FT=1’b0； BGA 〈= BGA+ 1；end
end
7: begin if(BGA1〉122)begin FT8=1'b1； BGA1〈=0; end // 接收波特=128000*16
else begin FT8=1'b0; BGA1 〈= BGA1+ 5；end
if(BGA〉3125) begin FT=1’b1； BGA<=0；FT8=1'b1; BGA1<=0; end // 发送波特=128000
else begin FT=1'b0； BGA <= BGA+ 8；end
end
default：begin BGA〈=0；FT=1’b0;end
endcase
endmodule
//接收模块
module trans_r（clk_r,rst_r,BTI_r，RxD_r，RxD_data_r，wren_r，addro_r,RxD_end）；
input clk_r,rst_r,RxD_r，BTI_r；
output ［7：0］RxD_data_r；
output wren_r，RxD_end；
output [7：0］addro_r；
reg ［3:0]bit_spacing；//两Bit间隔16
reg RxD_end; //接收数据有效标志
reg RxD_delay; //中间参量
reg RxD_en； //接收使能
reg ［7:0］RxD_data_r； //接收数据输出
reg ［7：0]RxD_cach； //接收数据缓存
reg [3:0］state；
reg [7：0］addro_r; //地址
reg wren_r；
assign Baud8Tick = BTI_r;//接收波特
always ＠（posedge clk_r or negedge rst_r)
if(～rst_r）
bit_spacing〈=0；
else
case(state)
0： bit_spacing〈=0;
default：if（Baud8Tick)bit_spacing〈=bit_spacing+1；
endcase
wire next_bit=（bit_spacing==5）；//两bit间隔16波特
always ＠(posedge clk_r)
if(Baud8Tick)
begin
RxD_delay〈=RxD_r;
RxD_en〈=（Baud8Tick & RxD_delay & （～RxD_r))；//检测接收信号是否有下降沿
end
//状态机接收
always＠（posedge clk_r or negedge rst_r）
if（～rst_r）
state 〈= 4'b0000；
else if（Baud8Tick）
case（state)
4'b0000: if(RxD_en） state 〈= 4’b0001； // 有下降沿开始接收
4’b0001： if（next_bit) state 〈= 4’b1000; // bit 0
4’b1000： if（next_bit） state 〈= 4’b1001； // bit 1
4’b1001： if(next_bit) state 〈= 4’b1010; // bit 2
4’b1010: if(next_bit） state 〈= 4’b1011; // bit 3
4’b1011： if(next_bit) state 〈= 4’b1100； // bit 4
4'b1100: if(next_bit) state 〈= 4’b1101； // bit 5
4'b1101： if（next_bit） state <= 4’b1110; // bit 6
4’b1110： if（next_bit) state 〈= 4’b1111； // bit 7
4’b1111： if（next_bit） state 〈= 4’b0010; // 停止位
4’b0010： if（next_bit） state 〈= 4’b0000;
default: state <= 4’b0000；
endcase
// 移位寄存器接收
always @(posedge clk_r or negedge rst_r)
if(～rst_r)
RxD_cach 〈= 8'b00000000；
else if（Baud8Tick &＆ next_bit ＆＆ state[3]）
RxD_cach 〈= {RxD_r， RxD_cach[7：1]｝；
//停止位与接收结束标志位有效时将数据输出
always ＠(posedge clk_r or negedge rst_r)
if（~rst_r)
RxD_data_r <= 8’b00000000;
else if(RxD_end &＆ RxD_r）
RxD_data_r 〈= RxD_cach;
// 产生接收结束标志位
always @(posedge clk_r or negedge rst_r）
if（~rst_r）
begin RxD_end<=0；end
else
begin RxD_end〈=(Baud8Tick && next_bit ＆& state==4'b0010 ＆＆ RxD_r);
end
always @（posedge clk_r or negedge rst_r）
if(～rst_r）
begin wren_r<=0;end
else if（RxD_end)wren_r<=1;
else wren_r〈=0；
//地址计数器ddress
always @(posedge clk_r or negedge rst_r）
if(～rst_r)
addro_r 〈= 8’b11111111；
else if（RxD_end）
addro_r <=addro_r +1；
endmodule
为了测试收发是否正常，写的Test Bench
`timescale 1ns/1ns
module trsb；
reg clk,rst,en；
reg [7：0］TxD_data;
reg ［2:0]Wsec;
wire TxD,TxD_busy，rcven;
wire [7：0]RxD_data；
trans trsb（.clk（clk)，
.rst（rst），
。en(en），
.TxD（TxD），
。Wsec（Wsec)，
。TxD_busy(TxD_busy)，
。TxD_data（TxD_data）,
.rcven（rcven),
。RxD_data(RxD_data),
。RxD(TxD）
);
initial begin
en = 0；
TxD_data = 0；
rst = 1；
＃1 Wsec=2;
＃54 rst=0；
＃70 rst=1；
#10 TxD_data = 8'b11011001;
#10 en = 1’b1;
＃1250000 en = 1'b1;
end
initial begin
#3790000 TxD_data = 8'b01011010；
＃10 en = 1’b1；
＃2750000 en = 1’b0;
#1290000 TxD_data = 8’b101001010；
#10 en = 1'b1；
#2750000 en = 1’b0；
end
initial begin
clk = 1;
while （1)
＃10 clk = ～clk；
end
endmodule
FPGA实现串行接口 RS232（1)
2008—12—17 11：38
串行接口（RS—232)
串行接口是连接FPGA和PC机的一种简单方式。这个项目向大家展示了如果使用FPGA来创建RS—232收发器。
整个项目包括5个部分
1. RS232是怎样工作的
2. 如何产生需要的波特率
3. 发送模块
4. 接收模块
5. 应用实例
RS—232接口是怎样工作的
作为标准设备,大多数的计算机都有1到2个RS—232串口.特性
RS—232有下列特性：
· 使用9针的"DB—9"插头（旧式计算机使用25针的”DB-25”插头）。
· 允许全双工的双向通讯（也就是说计算机可以在接收数据的同时发送数据）。
· 最大可支持的传输速率为10KBytes/s。
DB—9插头你可能已经在你的计算机背后见到过这种插头
它一共有9个引脚，但是最重要的3个引脚是：
· 引脚2： RxD （接收数据)。
· 引脚3： TxD （发送数据）。
· 引脚5： GND （地）。
仅使用3跟电缆，你就可以发送和接收数据。串行通讯数据以每次一位的方式传输;每条线用来传输一个方向的数据。由于计算机通常至少需要若干位数据，因此数据在发送之前先“串行化”。通常是以8位数据为1组的. .先发送最低有效位，最后发送最高有效位。异步通讯RS-232使用异步通讯协议.也就是说数据的传输没有时钟信号.接收端必须有某种方式，使之与接收数据同步.
对于RS-232来说，是这样处理的：
1. 串行线缆的两端事先约定好串行传输的参数(传输速度、传输格式等）
2. 当没有数据传输的时候，发送端向数据线上发送”1"
3. 每传输一个字节之前，发送端先发送一个”0"来表示传输已经开始。这样接收端便可以知道有数据到来了。
4. 开始传输后，数据以约定的速度和格式传输，所以接收端可以与之同步
5. 每次传输完成一个字节之后，都在其后发送一个停止位(”1"）
让我们来看看0x55是如何传输的：
0x55的二进制表示为：01010101。
但是由于先发送的是最低有效位，所以发送序列是这样的: 1-0—1—0—1—0-1—0。
下面是另外一个例子 ：
传输的数据为0xC4,你能看出来吗?
从图中很难看出来所传输的数据,这也说明了事先知道传输的速率对于接收端有多么重要。数据传输可以多快？数据的传输速度是用波特来描述的，亦即每秒钟传输的数据位，例如1000波特表示每秒钟传输100比特的数据, 或者说每个数据位持续1毫秒.
波特率不是随意的，必须服从一定的标准,如果希望设计123456波特的RS-232接口,对不起，你很不幸运，这是不行的。常用的串行传输速率值包括以下几种:
· 1200 波特。
· 9600 波特。
· 38400 波特。
· 115200 波特 (通常情况下是你可以使用的最高速度）。
在115200 波特传输速度下， 每位数据持续 （1/115200） = 8。7μs。 如果传输8位数据,共持续 8 x 8。7μs = 69μs.但是每个字节的传输又要求额外的“开始位”和“停止位”,所以实际上需要花费10 x 8。7μs = 87μs的时间。最大的有效数据传输率只能达到 11.5KBytes每秒.在115200 波特传输速度下，一些使用了不好的芯片的计算机要求一个长的停止位（1。5或2位数据的长度)，这使得最大传输速度降到大约10.5KBytes每秒物理层
电缆上的信号使用正负电压的机制：
· ”1" 用 -10V 的电压表示(或者在 -5V 与 —15V之间的电压）。
· ”0" 用 +10V 的电压表示（或者在 5V 与 15V之间的电压）。
所以没有数据传输的电缆上的电压应该为—10V或-5到-10之间的某个电压。
FPGA实现串行接口 RS232(2)
2008—12-17 11:39
波特率发生器
这里我们使用串行连接的最大速度115200波特，其他较慢的波特也很容易由此产生。
FPGA通常运行在远高于115200Hz的时钟频率上（对于今天的标准的来说RS—232真是太慢了），这就意味着我们需要用一个较高的时钟来分频产生尽量接近于115200Hz的时钟信号.
从1。8432MHz的时钟产生
通常RS—232芯片使用1。8432MHz的时钟，以为这个时钟很容易产生标准的波特率,所以我们假设已经拥有了一个这样的时钟源.
只需要将 1。8432MHz 16分频便可得到 115200Hz的时钟，多方便啊!
reg ［3:0] BaudDivCnt;
always @(posedge clk) BaudDivCnt 〈= BaudDivCnt + 1；
wire BaudTick = （BaudDivCnt==15）；
所以 ”BaudTick” 每16个时钟周期需要置位一次，从而从1。8432MHz的时钟得到115200Hz的时钟.从任意频率产生
早期的发生器假设使用1。8432MHz的时钟。但如果我们使用2MHz的时钟怎么办呢?要从2MHz的时钟得到 115200Hz，需要将时钟 ”17.361111111。。。” 分频，并不是一个整数。我的解决办法是有时候17分频，有时候18分频，使得整体的分频比保持在 ”17.361111111”.这是很容易做到的。
下面是实现这个想法的C语言代码：
while（1） // 死循环
{
acc += 115200；if（acc 〉=2000000） printf("*”）； else printf(” ”)；
acc %= 2000000；
｝
这段代码会精确的以平均每 ”17.361111111。.。” 个时钟间隔打印出一个”＊"。
为了从FPGA得到同样的效果，考虑到串行接口可以容忍一定的波特率误差，所以即使我们使用17。3或者17.4这样的分频比也是没有关系的.FPGA波特率发生器我们希望2000000是2的整数幂，但很可惜，它不是。所以我们改变分频比，"2000000/115200” 约等于 ”1024/59” = 17.356. 这跟我们要求的分频比很接近,并且使得在FPGA上实现起来相当有效。
//10 位的累加器 ([9:0］）， 1位进位输出 （[10］）
reg ［10:0] acc； //一共11位！
always @(posedge clk）
acc <= acc[9：0］ + 59； //我们使用上一次结果的低10位,但是保留11位结果
wire BaudTick = acc[10］； //第11位作为进位输出
使用 2MHz 时钟, ”BaudTick" 为 115234 波特， 跟理想的115200波特存在 0.03％ 的误差。参数化的FPGA波特率发生器
前面的设计我们使用的是10位的累加器，如果时钟频率提高的话，需要更多的位数.
下面是一个使用 25MHz 时钟和 16 位累加器的设计,该设计是参数化的，所以很容易根据具体情况修改。
parameter ClkFrequency = 25000000； // 25MHz
parameter Baud = 115200；
parameter BaudGeneratorAccWidth = 16;
parameter BaudGeneratorInc = (Baud〈〈BaudGeneratorAccWidth)/ClkFrequency；
reg [BaudGeneratorAccWidth：0］ BaudGeneratorAcc；
always ＠(posedge clk）
BaudGeneratorAcc 〈= BaudGeneratorAcc［BaudGeneratorAccWidth-1：0］ + BaudGeneratorInc；
wire BaudTick = BaudGeneratorAcc[BaudGeneratorAccWidth］;
上面的设计中存在一个错误： ”BaudGeneratorInc”的计算是错误的， 因为 Verilog 使用 32 位的默认结果， 但实际计算过程中的某些数据超过了32位，所以改变一种计算方法。
parameter BaudGeneratorInc = (（Baud<〈(BaudGeneratorAccWidth—4））+（ClkFrequency〉〉5）)/（ClkFrequency〉〉4);
这行程序也使得结果成为整数,从而避免截断。
这就是整个的设计方法了。
现在我们已经得到了足够精确的波特率，可以继续设计串行接收和发送模块了。
FPGA实现串行接口 RS232(3）
2008—12-17 11：40
RS-232发送模块
下面是我们所想要实现的：
它应该能像这样工作：
· 发送器接收8位的数据，并将其串行输出。（"TxD_start"置位后开始传输）。
· 当有数传输的时候，使”busy”信号有效，此时“TxD_start”信号被忽略。
RS—232模块的参数是固定的： 8位数据， 2个停止位， 无奇偶校验。数据串行化假设我们已经有了一个115200波特的”BaudTick”信号.
我们需要产生开始位、8位数据以及停止位。
用状态机来实现看起来比较合适。
reg ［3：0］ state；
always ＠（posedge clk）
case(state）
4’b0000： if(TxD_start） state 〈= 4'b0100；
4'b0100： if(BaudTick) state 〈= 4’b1000; // 开始位
4'b1000： if（BaudTick） state <= 4’b1001； // bit 0
4’b1001: if（BaudTick) state <= 4'b1010； // bit 1
4’b1010： if(BaudTick） state 〈= 4'b1011； // bit 2
4'b1011： if(BaudTick） state <= 4'b1100; // bit 3
4’b1100： if（BaudTick) state 〈= 4’b1101； // bit 44'b1101: if(BaudTick） state 〈= 4’b1110； // bit 5
4'b1110： if(BaudTick） state <= 4’b1111； // bit 6
4’b1111: if（BaudTick) state 〈= 4'b0001； // bit 7
4’b0001： if(BaudTick） state 〈= 4'b0010; // 停止位1
4’b0010： if（BaudTick) state 〈= 4'b0000; // 停止位2
default： if(BaudTick) state <= 4'b0000；
endcase
注意看这个状态机是怎样实现当"TxD_start"有效就开始，但只在"BaudTick"有效的时候才转换状态的。。
现在，我们只需要产生"TxD”输出即可。
reg muxbit；
always ＠（state［2：0］)
case（state[2：0]）
0： muxbit <= TxD_data［0］;
1： muxbit 〈= TxD_data[1］;
2: muxbit 〈= TxD_data[2］;
3： muxbit <= TxD_data[3]；
4: muxbit 〈= TxD_data［4];
5： muxbit 〈= TxD_data［5]；
6： muxbit <= TxD_data[6]；
7： muxbit <= TxD_data［7］；
endcase
//将开始位、数据以及停止位结合起来
assign TxD = （state〈4） ｜ （state[3］ & muxbit)；
FPGA实现串行接口 RS232（4）
2008-12—17 11:41
RS232接收模块下面是我们想要实现的模块：我们的设计目的是这样的：
     1。当RxD线上有数据时，接收模块负责识别RxD线上的数据
     2.当收到一个字节的数据时,锁存接收到的数据到”data"总线,并使”data_ready”有效一个周期。注意：只有当"data_ready”有效时，”data"总线的数据才有效,其他的时间里不要使用”data”总线上的数据,因为新的数据可能已经改变了其中的部分数据。
过采样异步接收机必须通过一定的机制与接收到的输入信号同步（接收端没有办法得到发送断的时钟）.这里采用如下办法。
     1。为了确定新数据的到来，即检测开始位，我们使用几倍于波特率的采样时钟对接收到的信号进行采样。
     2。一旦检测到”开始位"，再将采样时钟频率降为已知的发送端的波特率。典型的过采样时钟频率为接收到的信号的波特率的16倍，这里我们使用8倍的采样时钟。当波特率为115200时，采样时钟为921600Hz。
假设我们已经有了一个8倍于波特率的时钟信号 ”Baud8Tick",其频率为 921600Hz。具体设计
首先,接受到的”RxD”信号与我们的时钟没有任何关系，所以采用两个D触发器对其进行过采样，并且使之我我们的时钟同步。
reg [1：0］ RxD_sync;
always ＠(posedge clk) if（Baud8Tick） RxD_sync <= {RxD_sync[0］， RxD}；
首先我们对接收到的数据进行滤波,这样可以防止毛刺信号被误认为是开始信号。
reg [1：0］ RxD_cnt;
reg RxD_bit;
always ＠（posedge clk)
if（Baud8Tick）
begin
if（RxD_sync[1] ＆＆ RxD_cnt!=2’b11) RxD_cnt <= RxD_cnt + 1;
el