基于FPGA的串口设计

基于FPGA的串口设计【转】
前两天看见了一个关于FPGA的串口设计方法，感觉很好，特此分享一下，如果大家觉得不好，通知我，我把它在删除掉。

过采样到0开始传输，紧跟8位数据，然后上拉1结束。让我们来看看0x55是如何传输的:        0x55的二进制表示为：01010101。
        但是由于先发送的是最低有效位，所以发送序列是这样的: 1-0-1-0-1-0-1-0.
        电缆上的信号使用正负电压的机制:
        "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;
        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);
        这行程序也使得结果成为整数，从而避免截断。
        这就是整个的设计方法了。
        现在我们已经得到了足够精确的波特率，可以继续设计串行接收和发送模块了。
        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。
        假设我们已经有了一个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

先顶个然后看帖

第一遍没看懂，继续参悟

正在看！！！！！！

正是我所想要的，太感谢了