串口通信实现-串口接收（vivado&verilog版）

已于 2023-09-04 17:46:49 修改
阅读量4k 收藏 45
点赞数 7
分类专栏： FPGA代码分享 文章标签： fpga开发
于 2023-02-16 10:20:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wd12306/article/details/129054468
版权

串口系列知识分享：
（1）串口通信实现-串口发送
（2）串口通信发送多字节数据
（3）串口通信实现-串口接收
（4）UART 通信-使用VIO进行板级验证
（5）串口接收-控制LED闪烁
（6）使用串口发送实现ACX720开发板时钟显示
（7）串口发送+RAM+VGA传图

串口通信实现-串口发送（vivado&verilog版）

前言

此文介绍uart串口协议（串口接收）的verilog实现和testbench的编写，仿真环境为vivado 2018.3。

一、串口的通信协议

要进行模块的设计，首先要了解该部分功能的原理。这就涉及到串口的通信协议。
1
从这个图中可以看到，在RX信号线中，空闲状态是高电平。也就是说在不传输信息的时候，信号线置高。拉低的信号就是起始信号，也就是要开始传输数据的信号。第一位是起始位，紧跟后面的是数据位，随后有校验位和停止位。

【设计思路】：

  1. 空闲状态： 高电平
  2. 起始位： 拉低并且持续一位的时间，也就是持续 1/bps 的时间
  3. 数据位： 从这位开始就是数据位，数据位的长度从5 到 8 不等。最常见的是8位数据位。
  4. 校验位： 作为数据的校验位。
  5. 停止位： 拉高持续0.5，1 或者 2个时钟，只要接收双方协议好即可。

这就是一帧数据中包含的信息量，其中对接收方来说最重要的自然是数据位。需要准确的从中提取出数据位，来进行下一步的处理。

其中校验位的设计又有多种选择，校验方法有奇校验（odd）、偶校验（even）、0校验（space）、1校验（mark）及无校验（noparity）。常见的就是无校验，或者奇偶校验。

无校验位:就是不设置校验位，直接跟上停止位。

奇偶校验位根据数据位中1 的个数来设计。
奇校验位：如果数据位中1 的个数为奇数个，则该位为0。如果数据位中1 的个数为偶数个，则该位为1。也就是要求数据位与校验位中 1 的个数为奇数。

偶校验位：和奇校验位相反。如果数据位中1 的个数为奇数个，则该位为1。如果数据位中1 的个数为偶数个，则该位为0。也就是要求数据位与校验位中 1 的个数为偶数。
————————————————

二、分模块设计

这次模块的设计让我也是重新的认识到 Verilog 语言设计新的一种格式。先设计好每一个相应的模块，在合理的将每个模块联系起来，形成需要的模块。这种方式使得整体的进程可以进行的比较有条理。下面我们先来进行第一步，分模块的设计。

1.检测模块

首先第一个是检测模块。该模块的功能是检测信号线的下降沿，也就是起始位的开始。那么只要做一个下降沿来的时候，产生一个时钟的高脉冲即可。

 reg [1:0]uart_rx_r;
 always@(posedge Clk)begin  //uart_rx为输入数据
        uart_rx_r[0] <= uart_rx;
        uart_rx_r[1] <= uart_rx_r[0] ;
   end
 wire nedge_uart_rx;
//assign nedge_uart_rx = ((uart_rx_r[1] == 1) && (uart_rx_r[0] == 0));  
assign nedge_uart_rx = (uart_rx_r == 2'b10);       //下降沿检测

2
根据上图知在uart_rx出现下降沿时，nedge_uart_rx会在下一个时钟上升沿出现高电平信号。

2.波特率设置

代码如下（示例）：

reg [8:0]  Bps_DR;      //波特率设置
    always@(*)
        case(Baud_Set)
            0:Bps_DR = 1000000000/9600/16/20 - 1;
            1:Bps_DR = 1000000000/19200/16/20 - 1;
            2:Bps_DR = 1000000000/38400/16/20 - 1;
            3:Bps_DR = 1000000000/57600/16/20 - 1;
            4:Bps_DR = 1000000000/115200/16/20 - 1;
            default:Bps_DR = 1000000000/9600/16/20 - 1;
        endcase

此处为防止信号传输过程中产生干扰，将每一位信号分为16进行判断，舍去前5段，后五段，留中间5段进行判断。
3

reg [8:0]div_cnt;
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n)    
        div_cnt <= 0;
    else if(RX_EN)begin
        if(div_cnt == Bps_DR)
            div_cnt <= 0;
        else
            div_cnt <= div_cnt + 1'b1;
    end
    else
        div_cnt <= 0;


    wire bps_clk_16x;      //取每个信号的中点值 
    assign bps_clk_16x = (div_cnt == Bps_DR / 2);

    
    reg [7:0]bps_cnt;
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        bps_cnt <= 0;
    else if(RX_EN)begin
        if(bps_clk_16x)begin
            if(bps_cnt == 160)
                bps_cnt <= 0;
            else
                bps_cnt <= bps_cnt + 1'b1;
        end
        else
            bps_cnt <= bps_cnt;
     end
     else
        bps_cnt <= 0;

3.判断过程

//reg width name number/depth
    reg[2:0]r_data[7:0];
    reg [2:0]sta_bit;
    reg [2:0]sto_bit;
    
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) begin
        sta_bit <= 0;
        sto_bit <= 0;
        r_data[0] <= 0;
        r_data[1] <= 0;
        r_data[2] <= 0;
        r_data[3] <= 0;
        r_data[4] <= 0;
        r_data[5] <= 0;
        r_data[6] <= 0;
        r_data[7] <= 0;
    end
    else if(bps_clk_16x)begin
        case(bps_cnt)
            0:begin
                sta_bit <= 0;
                sto_bit <= 0;
                r_data[0] <= 0;
                r_data[1] <= 0;
                r_data[2] <= 0;
                r_data[3] <= 0;
                r_data[4] <= 0;
                r_data[5] <= 0;
                r_data[6] <= 0;
                r_data[7] <= 0;
            end
            5,6,7,8,9,10,11:sta_bit <= sta_bit + uart_rx;
            21,22,23,24,25,26,27: r_data[0] <= r_data[0] + uart_rx;
            37,38,39,40,41,42,43: r_data[1] <= r_data[1] + uart_rx;
            53,54,55,56,57,58,59: r_data[2] <= r_data[2] + uart_rx;
            69,70,71,72,73,74,75: r_data[3] <= r_data[3] + uart_rx;
            85,86,87,88,89,90,91: r_data[4] <= r_data[4] + uart_rx;
            101,102,103,104,105,106,107: r_data[5] <= r_data[5] + uart_rx;
            117,118,119,120,121,122,123: r_data[6] <= r_data[6] + uart_rx;
            133,134,135,136,137,138,139: r_data[7] <= r_data[7] + uart_rx;
            149,150,151,152,153,154,155: sto_bit <= sto_bit + uart_rx;
            default:;
        endcase
    end
        
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        Data <= 0;        
    else if(bps_clk_16x && (bps_cnt == 159))begin
        Data[0] <= (r_data[0] >= 4)?1'b1:1'b0;
        Data[1] <= (r_data[1] >= 4)?1'b1:1'b0;
        Data[2] <= (r_data[2] >= 4)?1'b1:1'b0;
        Data[3] <= (r_data[3] >= 4)?1'b1:1'b0;
        Data[4] <= (r_data[4] >= 4)?1'b1:1'b0;
        Data[5] <= (r_data[5] >= 4)?1'b1:1'b0;
        Data[6] <= (r_data[6] >= 4)?1'b1:1'b0;
        Data[7] <= (r_data[7] >= 4)?1'b1:1'b0;
    end

三、完整代码展示

module uart_byte_rx(
    Clk,
    Reset_n,
    Baud_Set,
    uart_rx,
    Data,
    Rx_Done,  
);

   input Clk;
   input Reset_n;
   input [2:0]Baud_Set;
   input uart_rx;
   output reg[7:0]Data; 
   output reg Rx_Done;
   
   reg [1:0]uart_rx_r;
   always@(posedge Clk)begin
        uart_rx_r[0] <= uart_rx;
        uart_rx_r[1] <= uart_rx_r[0] ;
   end

    wire pedge_uart_rx;
//    assign pedge_uart_rx = ((uart_rx_r[1] == 0) && (uart_rx_r[0] == 1));
    assign pedge_uart_rx = (uart_rx_r == 2'b01);      
    wire nedge_uart_rx;
//    assign nedge_uart_rx = ((uart_rx_r[1] == 1) && (uart_rx_r[0] == 0));  
    assign nedge_uart_rx = (uart_rx_r == 2'b10);       //下降沿检测
 
    reg [8:0]  Bps_DR;      //波特率设置
    always@(*)
        case(Baud_Set)
            0:Bps_DR = 1000000000/9600/16/20 - 1;
            1:Bps_DR = 1000000000/19200/16/20 - 1;
            2:Bps_DR = 1000000000/38400/16/20 - 1;
            3:Bps_DR = 1000000000/57600/16/20 - 1;
            4:Bps_DR = 1000000000/115200/16/20 - 1;
            default:Bps_DR = 1000000000/9600/16/20 - 1;
        endcase
        
    wire bps_clk_16x;      //取每个信号的中点值 
    assign bps_clk_16x = (div_cnt == Bps_DR / 2);

    reg RX_EN;
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        RX_EN <= 0;
    else if(nedge_uart_rx)
        RX_EN <= 1;
    else if(Rx_Done || (sta_bit >= 4))
        RX_EN <= 0;
        
    reg [8:0]div_cnt;
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n)    
        div_cnt <= 0;
    else if(RX_EN)begin
        if(div_cnt == Bps_DR)
            div_cnt <= 0;
        else
            div_cnt <= div_cnt + 1'b1;
    end
    else
        div_cnt <= 0;

    reg [7:0]bps_cnt;
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        bps_cnt <= 0;
    else if(RX_EN)begin
        if(bps_clk_16x)begin
            if(bps_cnt == 160)
                bps_cnt <= 0;
            else
                bps_cnt <= bps_cnt + 1'b1;
        end
        else
            bps_cnt <= bps_cnt;
     end
     else
        bps_cnt <= 0;
       
    //reg width name number/depth
    reg[2:0]r_data[7:0];
    reg [2:0]sta_bit;
    reg [2:0]sto_bit;
    
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) begin
        sta_bit <= 0;
        sto_bit <= 0;
        r_data[0] <= 0;
        r_data[1] <= 0;
        r_data[2] <= 0;
        r_data[3] <= 0;
        r_data[4] <= 0;
        r_data[5] <= 0;
        r_data[6] <= 0;
        r_data[7] <= 0;
    end
    else if(bps_clk_16x)begin
        case(bps_cnt)
            0:begin
                sta_bit <= 0;
                sto_bit <= 0;
                r_data[0] <= 0;
                r_data[1] <= 0;
                r_data[2] <= 0;
                r_data[3] <= 0;
                r_data[4] <= 0;
                r_data[5] <= 0;
                r_data[6] <= 0;
                r_data[7] <= 0;
            end
            5,6,7,8,9,10,11:sta_bit <= sta_bit + uart_rx;
            21,22,23,24,25,26,27: r_data[0] <= r_data[0] + uart_rx;
            37,38,39,40,41,42,43: r_data[1] <= r_data[1] + uart_rx;
            53,54,55,56,57,58,59: r_data[2] <= r_data[2] + uart_rx;
            69,70,71,72,73,74,75: r_data[3] <= r_data[3] + uart_rx;
            85,86,87,88,89,90,91: r_data[4] <= r_data[4] + uart_rx;
            101,102,103,104,105,106,107: r_data[5] <= r_data[5] + uart_rx;
            117,118,119,120,121,122,123: r_data[6] <= r_data[6] + uart_rx;
            133,134,135,136,137,138,139: r_data[7] <= r_data[7] + uart_rx;
            149,150,151,152,153,154,155: sto_bit <= sto_bit + uart_rx;
            default:;
        endcase
    end
        
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        Data <= 0;        
    else if(bps_clk_16x && (bps_cnt == 159))begin
        Data[0] <= (r_data[0] >= 4)?1'b1:1'b0;
        Data[1] <= (r_data[1] >= 4)?1'b1:1'b0;
        Data[2] <= (r_data[2] >= 4)?1'b1:1'b0;
        Data[3] <= (r_data[3] >= 4)?1'b1:1'b0;
        Data[4] <= (r_data[4] >= 4)?1'b1:1'b0;
        Data[5] <= (r_data[5] >= 4)?1'b1:1'b0;
        Data[6] <= (r_data[6] >= 4)?1'b1:1'b0;
        Data[7] <= (r_data[7] >= 4)?1'b1:1'b0;
    end 
    
//    always@(posedge Clk or negedge Reset_n)
//    if(!Reset_n) 
//        Data <= 0;        
//    else if(bps_clk_16x && (bps_cnt == 159))begin
//        Data[0] <= r_data[0][2];
//        Data[1] <= r_data[1][2];
//        Data[2] <= r_data[2][2];
//        Data[3] <= r_data[3][2];
//        Data[4] <= r_data[4][2];
//        Data[5] <= r_data[5][2];
//        Data[6] <= r_data[6][2];
//        Data[7] <= r_data[7][2];
//    end 

    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        Rx_Done <= 0;
    else if((div_cnt == Bps_DR/2) && (bps_cnt == 160))
        Rx_Done <= 1;
    else
        Rx_Done <= 0; 
        
endmodule

四、TB文件

`timescale 1ns / 1ps

module uart_byte_rx_tb();

   reg Clk;
   reg Reset_n;
   wire [2:0]Baud_Set;
   reg uart_rx;
   wire [7:0]Data; 
   wire Rx_Done;
   
   assign Baud_Set = 4;
   
    uart_byte_rx uart_byte_rx(
        Clk,
        Reset_n,
        Baud_Set,
        uart_rx,
        Data,
        Rx_Done,  
    );
    
    initial Clk = 1;
    always#10 Clk = ~Clk;
    
    initial begin
       Reset_n = 0;
       uart_rx = 1;
       #201;
       Reset_n = 1;
       #200; 
       uart_tx_byte(8'h5a);
       #90000;
       uart_tx_byte(8'ha5);
       #90000;
       uart_tx_byte(8'h86);
       #90000;
       $stop;
    end
    
    task uart_tx_byte;
        input [7:0]tx_data;
        begin
            uart_rx = 1;
            #20;
            uart_rx = 0;
            #8680;
            uart_rx = tx_data[0];
            #8680;
            uart_rx = tx_data[1];
            #8680;
            uart_rx = tx_data[2];
            #8680;
            uart_rx = tx_data[3];
            #8680;
            uart_rx = tx_data[4];
            #8680;
            uart_rx = tx_data[5];
            #8680;
            uart_rx = tx_data[6];
            #8680;
            uart_rx = tx_data[7];
            #8680;
            uart_rx = 1;
            #8680;         
        end
    endtask
    
endmodule

五、仿真展示

5
【附件：】链接：https://pan.baidu.com/s/1UcO93C8R2Ab3M9OTqssEKw?pwd=84i9
提取码：84i9

C.V-Pupil
关注
专栏目录
串行接口（UART）------verilog实现串口接收模块
weixin_43070186的博客
11-15 1万+
一、串口基本概念 串行接口（Serial port），主要用于串行式逐位数据传输。常见的有一般计算机应用的RS-232（使用 25 针或 9 针连接器）和工业计算机应用的半双工RS-485与全双工RS-422。----------维基百科 按照电气标准划分，串口可以分为RS-232-C、RS-422、RS-485。 RS-232-C:也称标准接口，是目前最常用的一种串行通讯接口。台式计算机一...
一步步学习zynq软硬件协同开发（AX7010/20）【FPGA+ReWorks】：创建自定义IP实现rtc读写
Deep_l_zh的博客
12-26 4798
一、实验环境及目的 板卡：AX7010 Vivado版本：2017.4 开发机：I5  2.2GHZ  8GB  WIN7_X64 参考文档：《ALINX黑金ZYNQ7000开发平台配套教程》 实验目的：掌握ZYNQ PL端的开发流程，创建自定义IP的方法，在ReWorks下利用该IP对RTC进行访问。 黑金给出的实验是如何创建自定义IP，但是并没有对代码进行解读，可能对于FPGA会的...
Vivado 串口通信(UART)原理B ------串口接收仿真
hhh123987_的博客
02-19 1372
串口接收仿真实验
Verilog：UART串口接收模块
最新发布
2303_76814451的博客
10-10 806
Verilog实现UART串口接收模块，在vivado上进行仿真。
串口接收模块的verilog设计
12-05
UART(即Universal Asynchronous Receiver Transmitter)是数据通信及控制中广泛使用的一种全双工串行数据传输协议。本设计基于 FPGA器件实现对UART的波特率产生器、UART发送器和接收器及其整合电路的模块化设计，采用Verilog HDL语言对三个功能模块进行硬件描述。通过串口调试助手进行验证，其结果完全符合UART协议的要求和预期的结果。
Vivado 串口通信(UART)------串口发送
hhh123987_的博客
02-19 1471
Vivado 串口通信(UART)------串口发送
Vivado 串口通信(UART)原理A ------串口发送实验
hhh123987_的博客
02-08 1931
Vivado zynq串口通信之串口发送实验
vivado学习第二 串口通信
momo1354的博客
08-19 2693
vivado学习第二 串口通信 奇偶校验位  奇偶校验位分为奇数校验位和偶数校验位，奇数和偶数的判断标准是依据发送一串或者一帧数据中“1”的个数。 奇数校验：发送的数据位+奇数校验位中“1”的个数为奇数个，也就是说如果数据位的“1”的个数为奇数个，则奇数校验位为数字0；如果数据位的“1”的个数为偶数个，则奇数校验位为数字1。 偶数校验：发送的数据位+偶数校验位中“1”的个数为偶数个，也就...
Verilog——串口数据接收（状态机）
weixin_41788560的博客
07-03 4435
串口协议简介 串口时序图： 串口发送端口空闲时为高； 发送端口拉低表示数据传送即将开始； 字节数据低位先发； 字节发送后拉高，表示字节传送结束； 字节位宽可以不为8 ； 常用波特率有4800、9600、 1 15200等。 串口接收模块 RX为串口输入； data_out为接收到的串口字节(8位)； 每接收完成一个字节，en_data_out就产生一个同步脉冲； 用户见到en_data_out即可收数； 波特率为4800，系统时钟频率24MHz。 串口数据接收 空闲识别：一直为1
串口通信实现-串口发送（vivado&verilog版）
小王在努力...的博客
02-14 4602
此文介绍uart串口协议（串口发送）的verilog实现和testbench的编写，仿真环境为vivado 2018.3。
FPGA自学笔记--串口通信实现（vivado&verilog版）
lgk1996的博客
05-01 7955
最近做了两种通信协议的实现的练习（uart，spi），此文介绍uart串口协议（串口发送）的verilog实现和testbench的编写，考虑到还有部分同学使用vhdl，vhdl版本会随后发布。在以后的系列里，还会有介绍spi协议的文章，把我自己学习中遇到的困难和正确的解决方案记录下来，仿真环境为vivado 2018.3.
FPGA纯verilog代码实现串口协议帧解析，提供vivado工程源码及仿真
01-18
内容摘要：请看csdn博文 csdn博文链接如下： ... 注意！注意！注意！ 1、请先认真看csdn博文，觉得有用再买哦；...4、纯verilog实现串口协议帧数据解码； 4、了解vivado仿真文件的设计思路和方法，提供仿真源码；
基于verilog的RS232串口通信开发,平台为vivado2019.2
05-13
本项目基于Verilog语言，聚焦于在Vivado 2019.2环境下实现RS232串口通信的开发。以下是关于这个主题的详细知识点： 1. **Verilog语言**：Verilog是一种硬件描述语言(HDL)，用于设计、建模和验证数字电子系统。它...
FPGA MPSoC_XCZU2CG实现UART串口通信（Vivado Design Suite和Verilog HDL实现）
04-25
总结，利用Xilinx的FPGA MPSoC系列，尤其是XCZU2CG，实现UART串口通信涉及到Vivado Design Suite的使用，以及Verilog HDL编程技能。这个过程中，需要理解UART协议，配置和控制IP核，编写逻辑控制代码，并最终进行...
04_uart_test_串口通信_vivado_
10-01
在电子设计领域，UART（通用异步收发传输器）是一种常见的串行通信接口，用于设备间的通信。本文将深入探讨如何在Xilinx的Vivado工具中实现UART通信，结合给定的"04_uart_test"项目，我们将讨论UART的基本原理、...
吃饱没事做之——用Verilog实现串口接收
qq_33358243的博客
02-24 687
其实到这里，可以发现没有一点关于波特率的信息，因为波特率那是时钟管的事情，将外部时钟分频到需要的波特率后，做为时钟信号传进来就可以了。直接rx为0的时候，就进入读的状态。8次之后就回到stop状态。之后继续等待数据的到来。但ok信号好了的时候，数据就是完全读好的状态。这个串口接收用串口发送的简单改改就行了。和串口发送的测试的一起测试。发送的在发送的那篇文章里。
Verilog 学习第五节（串口接收部分）
weixin_46741734的博客
02-27 1772
波特率是指串口通信中，单位时间传输的二进制位数eg：115200对应的就是1s传输115200位，即传输一位需要1000000000/115200,若进行采样频率为波特率的16倍则需要再除以16对应于每次的采样的时间，由于内部时钟20ns的频率进行变化，所以想要计算对应的采样次数就需要再除以20~在实际板级运行的时候，当我们的time值更新时（25000000），counter的值已经大于该值，所以无法通过计数比较的方式清零，只能一直自加下去，直到32位计满了，溢出清零，然后才能正常的循环计数清零。
串口收发UART（Verilog HDL）
九里明兮
06-13 1186
文章摘要：本篇文章目标设计一个格式为起始位+8位数据（无校验）+停止位的串口收发，接收PC上位机RS232总线信号后，重新打包转发至PC端显示（形成回环），数据完整无错码情况。 关键词：异步时钟；亚稳态；异步串行通信；Verilog HDL
UART_uart_vivado中的uart核_vivado串口通信_422串口vivado_
09-30
串口通信vivado实现，带有仿真文件，可实现数据收发
串口接收数据verilog代码
01-20
1：接收串口命令程序 2：连续3个8bit为1个指令，第一个8bit为命令关键字，第二个8bit为地址，第3个8bit为命令内容
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

C.V-Pupil

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值