【Verilog串口篇2】UART接收模块及Testbench仿真程序

本文讲解FPGA串口通信的 接收模块 Verilog实现，即根据数据链路层协议，完成起始位、数据位、校验位和停止位的接收，通信参数如波特率可由用户配置。

1、接口描述
直接从模块接口描述说起，咋一看和发送模块十分相似，细看二者区别也很明显，发送是“并入串出”而接收是“串入并出”。

module UARTRecv #(parameter
    CLK_FREQ    = 50_000_000,  // 时钟频率
    BAUD_RATE   = 115200,  // 波特率
    WORD_LENGTH = 8,       // 数据位
    STOP_BITS   = 2,       // 停止位
                           // 2 仅用于发送，多发一个，防止接收端漏帧
    PARITY      = "NONE"   // ODD, EVEN 鸡肋，弃之
)
(
    input Clock,  // Clock = CLK_FREQ
    input nRst,
    input Rx,
    output reg [WORD_LENGTH-1:0] Word,  // Shift Reg, 实时存储接收到的数据位
    output reg Cplt  // 接收完成，一个时钟周期高电平
);

2、起始信号
对于异步通信，接收方根本不知道发送方何时开始发送，这就需要发送方先通知接收方“我要开始发送了，请做好接收准备”。具体怎么通知呢？在空闲状态，线路为“1”。发送方发送“0”作为起始位，标识数据传输开始。因此接收方需要检测线路从“1”到“0”的跳变，也即下降沿，即为起始信号。 程序中通过移位寄存器缓存四位数据，若前两位为“1”，后两位为“0”，则检测到下降沿。

/* 捕获接收起始信号：下降沿 */
wire recvStart;   // 起始标志
reg [3:0] rxBuf;  // 用于判断下降沿
always @(posedge Clock or negedge nRst) begin
    if (!nRst) 
        rxBuf <= 4'b1111;
    else 
        rxBuf <= {rxBuf[2:0],Rx};
    end
assign recvStart = rxBuf[3] & rxBuf[2] & ~rxBuf[1] & ~rxBuf[0];

3、采样点
既已捕获到起始信号，再来个波特率时钟，就可以接收数据了，就像发送一样，So Easy！深入思考一下，发送是个连续过程，而接收我们只是在波特率时钟处读取数据，是个采样过程，既然是采样，只采样一次是否不妥？这里，将每位平均分成九段，在每段的中点都进行采样，这样对一个位就采样了九次。至少从概率论角度分析，可以减少干扰的影响。生成采样点，程序中：SMP_CLK = CLK_FREQ / BAUD_RATE / 9 - 1，为什么这么计算这里就不啰嗦了，重点强调一下 -1 很有必要，这样可以使采样也即接收尽快完成，不至于在连续接收时丢帧。

/* 采样时钟计数及采样点生成 */
reg [log2(SMP_CLK)-1:0] sampleClk;  // 以采样周期计数，非波特率周期，九倍关系
reg samplePoint;  // 计数中点为采样点
always @(posedge Clock or negedge nRst) begin
    if (!nRst) begin
        sampleClk <= 'd0;
        samplePoint <= 1'b0;
    end
    else if (recvFlag) begin
        sampleClk <= (sampleClk == SMP_CLK) ? 'd0 : (sampleClk + 1'b1);
        samplePoint <= (sampleClk == SMP_CLK >> 1) ? 1'b1 : 1'b0;
    end
    else begin
        sampleClk <= 'd0;
        samplePoint <= 1'b0;
    end
end

4、采样结果
下一步是计算采样结果，考虑到时钟偏移导致前后采样值的不确定性，只取中间三次采样值，看“1”个数多还是“0”个数多，即为采样结果。可惜机器不会“看”，计算能力倒是很强，还是转换成计算问题吧。采样结果：sampleResult[1]

/* 记录采样次数及采样结果 */
reg [3:0] sampleCnt;     // 采样计数，9 次（0->8）
reg [1:0] sampleResult;  // 采样结果，中间三个相加，取高位
always @(posedge Clock or negedge nRst) begin
    if (!nRst) begin
        sampleCnt <= 4'd0;
        sampleResult <= 2'b00;
    end
    else if (recvFlag) begin
        if (samplePoint) begin
            sampleCnt <= (sampleCnt == 4'd8) ? 4'd0 : (sampleCnt + 1'b1);
            case (sampleCnt)
                4'd0: sampleResult <= 2'd0;
                4'd3, 4'd4, 4'd5: sampleResult <= sampleResult + Rx;
                default: sampleResult <= sampleResult;
            endcase
        end
        else begin
            sampleCnt <= sampleCnt;
            sampleResult <= sampleResult;
        end
    end
    else begin
        sampleCnt <= 4'd0;
        sampleResult <= 2'b00;
    end
end

5、波特率时钟
再次回到波特率时钟，毕竟接收本质上也是由波特率时钟控制的，注意程序是 在第 7个（从 0 计数）采样点处生成波特率时钟，而不是等到最后，为什么呢？另外，发送是在位的头部生成波特率时钟，而接收是在尾部。

/* 生成波特率时钟 */
wire bitClk;  // 波特率时钟
assign bitClk = samplePoint && (sampleCnt == 4'd7);  // Not 4'd8, 尽快完成，以免错过下一帧

6、接收状态机
万事俱备，正事却还没办，下面来说说接收过程。顺序执行状态机，直接贴上代码，再次声明，接收也是在波特率时钟控制下进行的。

/* 状态切换（固定格式） */
always @(posedge Clock or negedge nRst) begin
    if (!nRst) 
        cstate <= S_IDLE;
    else 
        cstate <= nstate;
end
/* 得到次态的组合逻辑，用 = 赋值 */
always @(*) begin
    case (cstate)
        S_IDLE: nstate = recvStart ? S_START : S_IDLE;
        S_START: nstate = bitClk ? S_WORD : S_START;
        S_WORD: nstate = count == WORD_LENGTH ? S_STOP : S_WORD;
        S_STOP: nstate = bitClk ? S_CPLT : S_STOP;
        S_CPLT: nstate = S_IDLE;
        default: nstate = S_IDLE;
    endcase
end
/* 状态输出（即相应状态需要执行的动作） */
always @(posedge Clock or negedge nRst) begin
    if (!nRst) begin
        count <= 'd0;
        Word <= 'd0;
        Cplt <= 1'b0;
    end 
    else begin
        case (cstate)  // Not nstate, 个人更易理解
            S_IDLE: begin 
                count <= 'd0;
                Cplt <= 1'b0;
            end
            S_WORD: begin
                // 采样结果移入寄存器，低位先发，故右移，用拼接实现
                Word <= bitClk ? {sampleResult[1],Word[WORD_LENGTH-1:1]} : Word;
                count <= bitClk ? count + 'd1 : count;
            end
            S_CPLT: Cplt <= 1'b1;
            default: Cplt <= 1'b0;  // 无意义
        endcase
    end
end

7、仿真程序
贴上代码，循环 10 次接收 3 个字节。

`timescale 1ns / 1ps
module testbench;
localparam
    CLK_FREQ    = 50_000_000,
    BAUD_RATE   = 115200,
    WORD_LENGTH = 8,
    STOP_BITS   = 2,
    PARITY      = "NONE";
reg clk, rst_n;
reg rx;
wire [WORD_LENGTH-1:0] recvWord;
wire recvCplt;
UARTRecv #(
    .CLK_FREQ(CLK_FREQ),
    .BAUD_RATE(BAUD_RATE),
    .WORD_LENGTH(WORD_LENGTH),
    .STOP_BITS(STOP_BITS),
    .PARITY(PARITY)
)
U0_UARTRecv(
    .Clock(clk),
    .nRst(rst_n),
    .Rx(rx),
    .Word(recvWord),
    .Cplt(recvCplt)
);
integer bitTime, idx, idxWord, idxBit;
reg [7:0] word [0:2];
initial begin
    clk = 0; rst_n = 0; rx = 1'b1; #10000; rst_n = 1; #10000;
    bitTime = 8680;  // 根据波特率设置位时间周期
    word[0] = 8'hfa; word[1] = 8'hff; word[2] = 8'ha5;
    for (idx=0; idx<10; idx=idx+1) begin  // 传输次数
        for (idxWord=0; idxWord<3; idxWord=idxWord+1) begin  // 传输字节
            rx = 1'b0; #bitTime; //start
            for (idxBit=0; idxBit<8; idxBit=idxBit+1) begin  // 传输位
                rx = word[idxWord][idxBit];
                #bitTime;
            end
            rx = 1'b1; #bitTime; //stop
        end
        #1000000;
    end
end
always begin
    #10 clk = ~clk;
end
endmodule