当前位置:   article > 正文

UART的verilog实现_uart verilog

uart verilog

1 串口的协议

串口的全称是通用异步收发传输器,主要用于数据间的串行传递,是一种全双工传输模式。它在发送数据时将并行的数据转换成串行数据来传输,在接收数据时,将收到的串行数据转化为并行数据。

uart在发送或者接收过程中的一帧数据由4部分组成,包括起始位、数据位、奇偶校验位和停止位。其中起始位标志着一帧数据的开始,停止位标志着一帧数据的结束。数据位是一帧数据中的有效数据,校验位可以分为奇校验还是偶校验。

起始位:
tx传输信号默认是低电平,当出现一个下降沿,且持续一个bit的时间的低电平,则认为传输了一个起始位

数据位
是传输的有效数据,数据的位宽是可以选择的,6,7,8位。

校验位:
可以对传输的数据的正确性进行一定程度的检查

停止位:
持续一个bit时间长的高电平,则认为是数据的结束

如下如所示:(数据位宽是一个字节)
在这里插入图片描述

波特率
对于波特率,表示一秒内需要传输多少bit的数据,比如9600bps,就是表示一秒要传播9600bit。

2 串口发送模块

在这里插入图片描述
信号的解释:

clk时钟
rst_n复位
tx_data发送的一字节的数据
tx_en发送数据的使能信号,为一个高脉冲
byte_finish成功发射了一字节的数据
tx发送的信号

设计的整体思路
总体思路是设计一个状态机,有五个状态,空闲状态(IDLE),开始状态(START)、发送数据(SEND_DATA)、校验(EVEN_ODD_CHECK)和停止(STOP)。

首先对于全局的数据放在一个文件中config.v中,其中代码如下:

`define CLK_FRE 50_000_000      //输入的时钟频率
`define BAUD_RATE 115200          //波特率
`define EVEN_CHECK 1            //1 :偶校验  0:奇校验
  • 1
  • 2
  • 3

uart_tx的模块代码如下:

`include "config.v"
module uart_tx (
    input   wire                    clk         ,
    input   wire                    rst_n       ,
    input   wire    [7:0]           tx_data     ,
    input   wire                    tx_en       ,

    output  wire                    byte_finish ,
    output  reg                     tx 
);

    localparam      IDLE            =   5'b00001    ,       //空闲
                    START           =   5'b00010    ,       //起始
                    SEND_DATA       =   5'b00100    ,       //发送数据
                    EVEN_OLD_CHECK  =   5'b01000    ,       //奇偶校验
                    STOP            =   5'b10000    ;       //停止
    

    localparam      CNT_MAX         =   `CLK_FRE / `BAUD_RATE ;

    reg     [31:0]  cnt         ;
    reg     [4:0]   state       ;
    reg     [4:0]   nx_state    ;
    reg     [2:0]   cnt_data    ;
    reg             even_check  ;
    reg             odd_check   ;

    wire            start_finish;       //起始位结束信号
    wire            bit_flag    ;       //发送每个数据的bit信号
    wire            byte_flag   ;       //成功发送一字节数据的标致
    wire            check_flag  ;       //奇偶校验的标志
    wire            stop_flag   ;       //停止位的标志
    wire            check       ;       //要发送的奇偶校验信号


    assign start_finish = (state == START) && (cnt == CNT_MAX - 1) ? 1'b1 : 1'b0;
    assign bit_flag     = (state == SEND_DATA) && (cnt == CNT_MAX - 1) ? 1'b1 : 1'b0;
    assign byte_flag    = bit_flag && (cnt_data == 3'd7) ? 1'b1 : 1'b0;
    assign check_flag = ((state == EVEN_OLD_CHECK) && (cnt == CNT_MAX - 1)) ? 1'b1 : 1'b0;
    assign stop_flag = ((state == STOP) && (cnt == CNT_MAX - 1)) ? 1'b1 : 1'b0;
    assign check = `EVEN_CHECK ? even_check : odd_check;
    //状态转移(时序逻辑)
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            state <= IDLE;
        end
        else begin
            state <= nx_state;
        end
    end

    //状态跳转(组合逻辑)
    always @(*) begin
        //nx_state <= IDLE;
        case(state)
            IDLE:       nx_state = (tx_en) ? START : IDLE;
            START:      nx_state =  (start_finish) ? SEND_DATA : START;
            SEND_DATA:  nx_state = byte_flag ? EVEN_OLD_CHECK : SEND_DATA;
            EVEN_OLD_CHECK: nx_state = check_flag ? STOP : EVEN_OLD_CHECK;
            STOP:       nx_state = stop_flag ? IDLE : STOP;
            default:    nx_state = IDLE;
        endcase
    end
    //对cnt计数器赋值
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            cnt <= 'd0;
        end
        else begin
            case(state)
            IDLE:       cnt <= 'd0;
            START:  begin
                        if(nx_state == START) begin
                            cnt <= cnt + 1'b1;
                        end
                        else if(nx_state == SEND_DATA) begin
                            cnt <= 'd0;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
            SEND_DATA:begin
                        if(nx_state == SEND_DATA) begin
                            if(bit_flag) begin
                                cnt <= 'd0;
                            end
                            else begin
                                cnt <= cnt + 1'b1;
                            end
                        end
                        else if(nx_state == EVEN_OLD_CHECK) begin
                            cnt <= 'd0;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
            EVEN_OLD_CHECK: cnt <= (nx_state == EVEN_OLD_CHECK) ? cnt + 1'b1 : (nx_state == STOP) ? 'd0 : cnt;
            STOP:   cnt <= (nx_state == STOP) ? cnt + 1'b1 : 1'b0;
            default:cnt <= 'd0;
            endcase
        end
    end
    //统计发送的数据的bit数
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            cnt_data <= 3'd0;
        end
        else if((state == SEND_DATA) && (cnt_data == 3'd7) && (bit_flag)) begin
            cnt_data <= 'd0;
        end
        else if((state == SEND_DATA) && (cnt_data < 3'd7) && (bit_flag)) begin
            cnt_data <= cnt_data + 1'b1;
        end
        else begin
            cnt_data <= cnt_data;
        end
    end
    //生成奇校验还是偶校验
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            even_check <= 1'b0;
            odd_check <= 1'b0;
        end
        else if(tx_en) begin
            even_check <= ^tx_data;
            odd_check  <= ~(^tx_data);
        end
        else begin
            even_check <= even_check;
            odd_check <= odd_check;
        end
    end
    assign byte_finish = stop_flag;
    //发送数据
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            tx <= 1'b1;
        end
        else begin
            case(nx_state)
                IDLE:       tx <= 1'b1;
                START:      tx <= 1'b0;
                SEND_DATA:  tx <= bit_flag ? tx_data[cnt_data+1] : tx_data[cnt_data];
                EVEN_OLD_CHECK:tx <= check;
                STOP:       tx <= 1'b1;
                default:    tx <= 1'b1;
            endcase
        end
    end

    
endmodule
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154

testbench如下:

`timescale 1ns/1ns
`define CLK_CYCLE 20

module tb_uart_tx;

    reg         clk         ;
    reg         rst_n       ;
    reg  [7:0]  tx_data     ;
    reg         tx_en       ;

    wire        byte_finish ;
    wire        tx          ;

    uart_tx     u_uart_tx(
    .  clk          (clk),
    .  rst_n        (rst_n),
    .  tx_data      (tx_data),
    .  tx_en        (tx_en),

    .  byte_finish  (byte_finish),
    .  tx           (tx)
);

initial begin
     clk = 1'b0;
     rst_n = 1'b0;
     tx_data = 8'h00;
     tx_en = 1'b0;
     #30
     rst_n = 1'b1;
     #100
     repeat (2) @(posedge clk);
     tx_en = 1'b1;
     tx_data = 8'h45;
     @(posedge clk);
     tx_en = 1'b0;
     @(negedge byte_finish);
     tx_en = 1'b1;
     tx_data = 8'h23;
     @(posedge clk);
     tx_en = 1'b0;
     @(byte_finish);
     #100
     $finish;
end

always #(`CLK_CYCLE / 2) clk = ~clk;

endmodule

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

仿真波形如下,可知成功发射了数据。
在这里插入图片描述

3 串口接收模块

在这里插入图片描述

信号的解释:

clk时钟
rst_n复位
tx接受到的单bit信号
rx_data接收到的一个字节数据
byte_finish一个字节数据接收的完成信号
error基于奇偶校验,判断接收的数据是否可信

设计的整体思路
总体思路是设计一个状态机,有五个状态,空闲状态(IDLE),开始状态(START)、接收数据(RV_DATA)、校验(CHECK)和停止(STOP)。需要指出的一点是,对于数据采样,选择一个bit信号中间采样,这样采样的数据才是较为可靠的。

uart_rx的模块如下:

`include "config.v"

module uart_rx(
    input   wire                clk         ,
    input   wire                rst_n       ,
    input   wire                tx          ,

    output  wire    [7:0]       rx_data     ,
    output  reg                 error       ,
    output  wire                byte_finish 
);

    localparam      IDLE    =       5'b00001    ,       //空闲
                    START   =       5'b00010    ,       //开始
                    RV_DATA =       5'b00100    ,       //接收数据
                    CHECK   =       5'b01000    ,       //奇偶校验
                    STOP    =       5'b10000    ;       //停止
    
    localparam      CNT_MAX     =   `CLK_FRE / `BAUD_RATE ;

    reg                     tx_dly      ;
    reg         [31:0]      cnt         ;
    reg         [4:0]       state       ;
    reg         [4:0]       nx_state    ;
    reg         [2:0]       cnt_bit     ;
    reg         [7:0]       rv_data     ;
    reg                     even_check  ;
    reg                     odd_check   ;

    wire                    tx_negedge  ;
    wire                    start_end   ;
    wire                    bit_flag    ;
    wire                    rv_end      ;
    wire                    sample_flag ;               //采样数据的信号
    wire                    check       ;
    wire                    check_end   ;
    wire                    stop_end    ;

    assign      start_end = (state == START) && (cnt == CNT_MAX - 2);

    assign      bit_flag = (state == RV_DATA) && (cnt == CNT_MAX - 1);

    assign      rv_end = (state == RV_DATA) && (bit_flag) && (cnt_bit == 3'd7);

    assign      sample_flag = ((state == RV_DATA) ) && (cnt == CNT_MAX / 2 - 1);

    assign      check = `EVEN_CHECK ? even_check : odd_check;

    assign      check_end = (state == CHECK) && (cnt == CNT_MAX - 1);

    assign      stop_end = (state == STOP) && (cnt == CNT_MAX - 1);

    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            tx_dly <= 1'b1;
        end
        else begin
            tx_dly <= tx;
        end
    end

    assign  tx_negedge = ((tx_dly) && (!tx)) ? 1'b1 : 1'b0;

    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            state <= IDLE;
        end
        else begin
            state <= nx_state;
        end
    end

    always @(*) begin
        case(state)
            IDLE:   nx_state = tx_negedge ? START : IDLE;
            START:  nx_state = start_end ? RV_DATA : START;
            RV_DATA:nx_state = rv_end ? CHECK : RV_DATA;
            CHECK:  nx_state = check_end ? STOP : CHECK;
            STOP:   nx_state = stop_end ? IDLE : STOP;
            default:nx_state = IDLE;
        endcase
    end

    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            cnt <= 'd0;
        end
        else begin
            case(state)
            IDLE:       cnt <= 'd0;
            START:  begin
                        if(nx_state == START) begin
                            cnt <= cnt + 1'b1;
                        end
                        else if(nx_state == RV_DATA) begin
                            cnt <= 'd0;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
            RV_DATA:begin
                        if(nx_state == RV_DATA) begin
                            if(bit_flag) begin
                                cnt <= 'd0;
                            end
                            else begin
                                cnt <= cnt + 1'b1;
                            end
                        end
                        else if(nx_state == CHECK) begin
                            cnt <= 'd0;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
            CHECK:  cnt <= (nx_state == CHECK) ? cnt + 1'b1 : 'd0;
            STOP :  cnt <= (nx_state == STOP) ? cnt + 1'b1 : 'd0;
            default:cnt <= 'd0;
            endcase
        end
    end

    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            cnt_bit <= 3'd0;
        end
        else if((bit_flag) && (nx_state == CHECK)) begin
            cnt_bit <= 3'd0;
        end
        else if(bit_flag) begin
            cnt_bit <= cnt_bit + 1'b1;
        end
        else begin
            cnt_bit <= cnt_bit;
        end
    end

    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            rv_data <= 8'h00;
        end
        else if(state == IDLE) begin
            rv_data <= 8'h00;
        end
        else if(sample_flag) begin
            rv_data <= {tx, rv_data[7:1]};
        end
        else begin
            rv_data <= rv_data;
        end
    end

    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            odd_check <= 1'b0;
            even_check <= 1'b0;
        end
        else if(nx_state == CHECK) begin
            even_check <= ^rv_data;
            odd_check <= ~(^rv_data);
        end
        else begin
            even_check <= even_check;
            odd_check <= odd_check;
        end
    end

    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            error <= 1'b0;
        end
        else if(nx_state == IDLE) begin
            error <= 1'b0;
        end
        else if(nx_state == STOP) begin
            error <= 1'b0;
        end
        else if((nx_state == CHECK) && sample_flag) begin
            error <= (tx != check) ? 1'b1 : 1'b0;
        end 
        else begin
            error <= error;
        end
    end

    assign rx_data = rv_data;

    assign byte_finish = (state == STOP) && (nx_state == IDLE);

endmodule
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192

4 uart发送和接收模块的联合仿真

uart的顶层如下:
在这里插入图片描述
uart模块代码如下,就是把发送和接收模块连接

module uart(
    input   wire                clk         ,
    input   wire                rst_n       ,
    input   wire    [7:0]       tx_data     ,
    input   wire                tx_en       ,

    output  wire    [7:0]       rx_data     ,
    output  wire                error       ,
    output  wire                rv_byte_finish
);

    wire            tx_byte_finish  ;
    wire            tx              ;

    uart_tx     u_uart_tx(
    .  clk         (clk),
    .  rst_n       (rst_n),
    .  tx_data     (tx_data),
    .  tx_en       (tx_en),

    .  byte_finish (tx_byte_finish),
    .  tx (tx)
);

    uart_rx u_uart_rx(
    . clk         (clk),
    . rst_n       (rst_n),
    . tx          (tx),

    . rx_data     (rx_data),
    . error       (error),
    . byte_finish (rv_byte_finish)
);


endmodule
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

仿真代码如下:

`timescale 1ns/1ns
`define CLK_CYCLE 20

module tb_uart;

    reg         clk         ;
    reg         rst_n       ;
    reg  [7:0]  tx_data     ;
    reg         tx_en       ;

    wire [7:0]  rx_data     ;
    wire        error       ;
    wire        rv_byte_finish;

    uart    u_uart(
    .   clk       (clk),
    .   rst_n     (rst_n),
    .   tx_data   (tx_data),
    .   tx_en     (tx_en),

    .   rx_data   (rx_data),
    .   error     (error),
    .   rv_byte_finish(rv_byte_finish)
);

    initial begin
     clk = 1'b0;
     rst_n = 1'b0;
     tx_data = 8'h00;
     tx_en = 1'b0;
     #30
     rst_n = 1'b1;
     #100
     repeat (2) @(posedge clk);
     tx_en = 1'b1;
     tx_data = 8'h45;
     @(posedge clk);
     tx_en = 1'b0;
     @(negedge rv_byte_finish);
     tx_en = 1'b1;
     tx_data = 8'h23;
     @(posedge clk);
     tx_en = 1'b0;
     @(rv_byte_finish);
     #100
     $finish;
end

always #(`CLK_CYCLE / 2) clk = ~clk;


endmodule
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

仿真波形如下,可见成功的接收到了数据。
在这里插入图片描述

5 总结

感觉自己对状态机的写法以及理解更加好了,至此三大通信协议都完成了。加油加油加油!!!

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/IT小白/article/detail/461614
推荐阅读
相关标签
  

闽ICP备14008679号