基于fpga的串口通信实现

FPGA ：实现串行接口  RS232

串行接口 (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 是如何传输的 :01010101

0x55 的二进制表示为： 01010101 。

但是由于先发送的是最低有效位，所以发送序列是这样的 : 1-0-1-0-1-0-1-0.

下面是另外一个例子 :

传输的数据为 0xC4 ，你能看出来吗 ?11000100

从图中很难看出来所传输的数据，这也说明了事先知道传输的速率对于接收端有多么重要。（ 串口发送的开始位为 0 ，结束位为 1 ，空闲 line 是为高 ）

数据传输可以多快 ?

数据的传输速度是用波特来描述的，亦即每秒钟传输的数据位，例如 1000 波特表示每秒钟传输 100 比特的数据 , 或者说每个数据位持续 1 毫秒 (1/1000) = 1ms 。

波特率不是随意的，必须服从一定的标准，如果希望设计 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 之间的某个电压。

 

波特率发生器

这里我们使用串行连接的最大速度 115200 波特，其他较慢的波特也很容易由此产生。

FPGA 通常运行在远高于 115200Hz 的时钟频率上（对于今天的标准的来说 RS-232 真是太慢了），这就意味着我们需要用一个较高的时钟来分频产生尽量接近于 115200Hz 的时钟信号。

从 1.8432MHz 的时钟产生

通常 RS-232 芯片使用 1.8432MHz 的时钟，以为这个时钟很容易产生标准的波特率，所以我们假设已经拥有了一个这样的时钟源。

只需要将 1.8432MHz 16 分频便可得到 115200Hz 的时钟，多方便啊！

reg [3:0] BaudDivCnt; （ 1843200/16=115200

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  FPGA 的工作频率

parameter Baud = 115200;

parameter BaudGeneratorAccWidth = 16;

parameter BaudGeneratorInc = (Baud< 左移的话意味着乘以 2 的几次方

reg [BaudGeneratorAccWidth:0] BaudGeneratorAcc; // 留出一位用于分频进位用的

always @(posedge clk)

BaudGeneratorAcc <= BaudGeneratorAcc[BaudGeneratorAccWidth-1:0] + BaudGeneratorInc;

wire BaudTick = BaudGeneratorAcc[BaudGeneratorAccWidth];// 这个式子就是我们分频的结果，达到了由 25MHZ 分频到 115200HZ 的效果

上面的设计中存在一个错误 : "BaudGeneratorInc" 的计算是错误的 , 因为 Verilog 使用 32 位的默认结果 , 但实际计算过程中的某些数据超过了 32 位，所以改变一种计算方法。

parameter BaudGeneratorInc = ((Baud<<(BaudGeneratorAccWidth-4))+(ClkFrequency>>5))/(ClkFrequency>>4);

这行程序也使得结果成为整数，从而避免截断。

这就是整个的设计方法了。

现在我们已经得到了足够精确的波特率，可以继续设计串行接收和发送模块了。

 

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 4

4'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);

 

RS232 接收模块

下面是我们想要实现的模块 :

我们的设计目的是这样的：

     1. 当 RxD 线上有数据时，接收模块负责识别 RxD 线上的数据

     2. 当收到一个字节的数据时，锁存接收到的数据到 "data" 总线，并使 "data_ready" 有效一个周期。

注意：只有当 "data_ready" 有效时， "data" 总线的数据才有效，其他的时间里不要使用 "data" 总线上的数据，因为新的数据可能已经改变了其中的部分数据。

过采样

异步接收机必须通过一定的机制与接收到的输入信号同步（接收端没有办法得到发送断的时钟）。这里采用如下办法。

     1. 为了确定新数据的到来，即检测开始位，我们使用几倍于波特率的采样时钟对接收到的信号进行采样。

     2. 一旦检测到 " 开始位 " ，再将采样时钟频率降为已知的发送端的波特率。

典型的过采样时钟频率为接收到的信号的波特率的 16 倍，这里我们使用 8 倍的采样时钟。当波特率为 115200 时，采样时钟为 921600Hz 。（ 115200*8=921600 ）

假设我们已经有了一个 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;

else

if(~RxD_sync[1] && RxD_cnt!=2'b00) RxD_cnt <= RxD_cnt - 1;

if(RxD_cnt==2'b00) RxD_bit <= 0;

else

if(RxD_cnt==2'b11) RxD_bit <= 1;

end

一旦检测到 " 开始位 " ，使用如下的状态机可以检测出接收到每一位数据。

reg [3:0] state;

always @(posedge clk)

if(Baud8Tick)

case(state)

4'b0000: if(~RxD_bit) state <= 4'b1000; // start bit found?

4'b1000: if(next_bit) state <= 4'b1001; // bit 0

4'b1001: if(next_bit) state <= 4'b1010; // bit 1

4'b1010: if(next_bit) state <= 4'b1011; // bit 2

4'b1011: if(next_bit) state <= 4'b1100; // bit 3

4'b1100: if(next_bit) state <= 4'b1101; // bit 4

4'b1101: if(next_bit) state <= 4'b1110; // bit 5

4'b1110: if(next_bit) state <= 4'b1111; // bit 6

4'b1111: if(next_bit) state <= 4'b0001; // bit 7

4'b0001: if(next_bit) state <= 4'b0000; // stop bit

default: state <= 4'b0000;

endcase

注意，我们使用了 "next_bit" 来遍历所有数据位。

reg [2:0] bit_spacing;

always @(posedge clk)

if(state==0)

bit_spacing <= 0;

else

if(Baud8Tick)

bit_spacing <= bit_spacing + 1;

wire next_bit = (bit_spacing==7);

最后我们使用一个移位寄存器来存储接受到的数据。

reg [7:0] RxD_data;

always @(posedge clk) if(Baud8Tick && next_bit && state[3]) RxD_data <= {RxD_bit, RxD_data[7:1]};

 

 

怎样使用发送和接收模块

这个设计似的我们可以通过计算机的串行口来控制 FPGA 的几个引脚。

具体来说，该设计完成以下功能。

   1. 将 FPGA 的 8 个引脚作为输出（称为 “ 通用输出 ” ）。 FPGA 收到任何数据时都会更新这 8 个 GPout 的值。

   2. 将 FPGA 的 8 个引脚作为输入（称为 “ 通用输入 ” ）。 FPGA 收到任何数据后，都会将 GPin 上的数值通过串行口发送出去。

通用输出可以用来通过计算机远程控制任何东西，例如 FPGA 板上的 LED ，甚至可以再添加一个继电器来控制咖啡机。

module serialfun(clk, RxD, TxD, GPout, GPin);

input clk;

input RxD;

output TxD;

output [7:0] GPout;

input [7:0] GPin;

///////////////////////////////////////////////////

wire RxD_data_ready;

wire [7:0] RxD_data;

async_receiver deserializer(.clk(clk), .RxD(RxD), .RxD_data_ready(RxD_data_ready), .RxD_data(RxD_data));

reg [7:0] GPout;

always @(posedge clk) if(RxD_data_ready) GPout <= RxD_data;

///////////////////////////////////////////////////

async_transmitter serializer(.clk(clk), .TxD(TxD), .TxD_start(RxD_data_ready), .TxD_data(GPin));

endmodule

记得包含异步发送和接收模块的设计文件，并更新里面的时钟频率。