【Verilog串口篇1】UART发送模块及Testbench仿真程序

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

1、通信参数
相信各位对于 通信参数：波特率、数据位、停止位和校验 并不陌生，因为在使用串口时，我们必须先配置这些属性。不过这里不仅限于配置，还有必要思考个问题：为什么需要这些参数呢？
归根结底，串口通信在线路中传输的只有“0”、“1”信号，就像这篇博客，在内存中也是以“0”、“1”的方式存储的。电脑之所以能将博客正确地显示出来，是因为这些二进制值看似杂乱无章，实则遵循了一套编码规则，如 Unicode 编码。参数的意义就在于规定了串口通信的编码规则：数据包格式和位时序，这样收发双方才能正确地发送和接收数据。 前面说的有点虚无缥缈，下面具体阐述各个参数的含义，这是收发模块设计的依据所在。
波特率 形象来说，波特率规定了位的时间长度，即位时序，相当于同步通信中的时钟信号。基于此，发送方在发送的时候，就知道一个位需要保持多长时间，接收方也能根据时间长度逐位接收数据。
数据位 有效数据长度，可选 5、6、7 或 8，常用 8 位，即 1 字节。
停止位 停止信号长度，常用 1 位或 2 位。何为停止信号？逻辑“1”信号。
校验位 可选奇校验、偶校验或无校验。校验比较鸡肋，食之无味、弃之可惜，有兴趣的读者可查阅其它资料。考虑到程序完整性，后面的模块接口中只给它留个位，并无作用。
程序设计中，还需要知道两个概念：时钟频率 用来产生波特率，起始信号 逻辑“0”信号。

2、接口描述
开门见山，直接贴出发送模块的接口描述代码。参数部分就是我们上文提到的几个概念，用户可传入客制化值进行配置。输入输出端口没什么特别之处，详见注释。

module UARTTrans #(parameter
    CLK_FREQ    = 50_000_000,  // 时钟频率
    BAUD_RATE   = 115200,  // 波特率
    WORD_LENGTH = 8,       // 数据位
    STOP_BITS   = 2,       // 停止位 1 或 2
                           // 2, 多发一个，防止接收端漏帧
    PARITY      = "NONE"   // ODD, EVEN 鸡肋，弃之
)
(
    input Clock,  // Clock = CLK_FREQ
    input nRst,
    input Trans,  // 启动传输
    input [WORD_LENGTH-1:0] Word,  // 待发送字符
                                   // 传输过程中认为保持不变，故程序中没有缓存
    output reg Tx,
    output reg Cplt   // 传输完成，一个时钟周期高电平
);

3、波特率时钟
前面说过，波特率规定了位时序，这个时序是怎么来的呢？系统时钟根据波特率分频生成波特率时钟。 其作用又是什么呢？发送模块在波特率时钟的控制下，逐位发送数据。以下是生成波特率时钟的代码。

/* 生成波特率时钟 */
reg [log2(BAUD_CNT)-1:0] baudCnt;  // 时钟计数
reg baudClk;  // 波特率时钟
always @(posedge Clock or negedge nRst) begin
    if (!nRst) begin
        baudCnt <= 'd0;
        baudClk <= 1'b0;
    end
    else if (transFlag) begin
        baudCnt <= (baudCnt == BAUD_CNT) ? 'd0 : (baudCnt + 1'b1);
        baudClk <= (baudCnt == 'd1) ? 1'b1 : 1'b0;  // baudCnt == 'd1 保险一点
                                                    // 思考 baudCnt == 'd0 存在的问题
    end
    else begin
        baudCnt <= 'd0;
        baudClk <= 1'b0;
    end
end

4、发送状态机
有了波特率时钟，就可以发送数据了。发送说起来很简单，无非就是基于波特率时钟，逐位发送，先发送起始位，再发送有效数据，最后发送停止位。 这是个顺序操作，状态机当然是不二之选。我们使用三段式状态机，先来看看得到次态的组合逻辑。

/* 得到次态的组合逻辑，用 = 赋值 */
always @(*) begin
    case (cstate)
        S_IDLE: nstate = Trans ? S_START : S_IDLE;
        S_START: nstate = baudClk ? S_WORD : S_START;
        S_WORD: nstate = count == WORD_LENGTH ? (STOP_BITS == 1 ? S_STOP2 : S_STOP1) : S_WORD;
        S_STOP1: nstate = baudClk ? S_STOP2 : S_STOP1;
        S_STOP2: nstate = baudClk ? S_CPLT : S_STOP2;
        // 和接收的区别：需要等待下一个波特率时钟，因为接收波特率时钟是在位的尾部，而发送在头部
        S_CPLT: nstate = baudClk ? S_IDLE : S_CPLT;
        default: nstate = S_IDLE;
 endcase
end

至于状态输出，也即相应状态需要执行的动作，这里当然是发送数据了。从程序中可以看出，数据发送的确是在波特率时钟的控制下进行的。需要说明一点，我们 假定输入数据在发送过程中不会改变，所以没有缓存待发送数据。

/* 状态输出（即相应状态需要执行的动作） */
always @(posedge Clock or negedge nRst) begin
    if (!nRst) begin
        // wordBuf <= 'd0;
        count <= 'd0;
        Tx <= 1'b1;
        Cplt <= 1'b0;
    end
    else begin
        case (cstate)
            S_IDLE: begin
                // wordBuf <= Trans ? Word : wordBuf;  // 缓存待发送数据
                Tx <= 1'b1;
                Cplt <= 1'b0;
                count <= 'd0;
            end
            S_START: Tx <= baudClk ? 1'b0 : Tx;  // 发送起始位
            S_WORD: begin
                // wordBuf <= baudClk ? {1'b0,wordBuf[WORD_LENGTH-1:1]} : wordBuf;
                // Tx <= baudClk ? wordBuf[0] : Tx;
                // 发送有效数据并计数
                Tx <= baudClk ? Word[count] : Tx;
                count <= baudClk ? count + 'd1 : count;
            end
            S_STOP1: Tx <= baudClk ? 1'b1 : Tx;  // 发送停止位 1
            S_STOP2: Tx <= baudClk ? 1'b1 : Tx;  // 发送停止位 2
            S_CPLT: Cplt <= baudClk ? 1'b1 : 1'b0;  // 需要等待波特率时钟，说明停止位发送完成
            default: begin
                Tx <= 1'b1;
                Cplt <= 1'b0;
            end
        endcase
    end
end

5、仿真程序
贴上完整的仿真程序，输出三个 8’hfa 和 三个 8’h5f，仿真执行流程见注释。这里强调一下，因为程序执行是时序逻辑，需要等待时钟，而仿真执行类似于组合逻辑，不需要等待时钟，一下子就执行完毕，所以仿真程序中多处需要保持或等待一个时钟周期。还需说明一点，一开始在 while 循环中，没有 #1; // 必须延时，否则程序卡死在 while 循环 这一句，结果就像注释所说的，卡死了，从仿真时序图上看，系统时钟也没有了输出。

`timescale 1ns / 1ps
module testbench;
localparam
    WORD_LENGTH = 8,
    STOP_BITS   = 2;
reg clk, rst_n, trans;
reg [WORD_LENGTH-1:0] transWord;
wire tx, transCplt;
UARTTrans #(
    .WORD_LENGTH(WORD_LENGTH),
    .STOP_BITS(STOP_BITS)
)
U0_UARTTrans(
    .Clock(clk),
    .nRst(rst_n),
    .Trans(trans),
    .Word(transWord),
    .Tx(tx),
    .Cplt(transCplt)
);
integer idx;
initial begin
    clk = 0; rst_n = 0; trans = 1'b0; #10000; rst_n = 1; #10000;
    transWord = 8'hfa;  // 待发送字节
    for (idx=0; idx<3; idx=idx+1) begin  // for 循环发送
        trans= 1'b1; #20; trans= 1'b0; // 启动传输，保持一个时钟周期
        while (transCplt == 0) #1;  // 等待传输完成
        #20;  // 等待一个时钟周期
    end
    transWord = 8'h5f;  // 待发送字节
    trans= 1'b1; #20; trans= 1'b0; // 启动传输，保持一个时钟周期
    while (idx < 5) begin  // while 循环发送
        if (transCplt) begin  // 传输完成
            #20;  // 等待一个时钟周期
            trans= 1'b1; #20; trans= 1'b0; // 启动传输，保持一个时钟周期
            idx = idx+1;
        end
        #1;  // 必须延时，否则程序卡死在 while 循环
    end
end
always #10 clk = ~clk;
endmodule