FPGA设计案例--通用UART收发模块设计

已于 2024-08-27 14:47:32 修改
阅读量206 收藏
点赞数 3
分类专栏： FPGA 文章标签： fpga开发
于 2024-08-27 14:41:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45645504/article/details/141602361
版权

        关于UART通信总线的基本概念相比大家都已熟知，这里就不再赘述了。本文旨在设计一个支持多种波特率、数据位宽以及校验位的通用UART接收和发送模块，接下来直接给出具体的代码。

通用UART收发模块Verilog代码

module Uart_Tx#(parameter   BAUD_RATE = 115200      ,//Baud Rate:9600,19200,38400,57600,115200,230400; default:115200
                            CLK_FREQY = 50_000_000  ,//System clk; default:50MHz
                            STOP_BIT  = 1           ,//Stop Bit Width:1 bit,2 bit; default:1 bit
                            CHECK_TYP = "NONE"      ,//Parity Check:0-NONE,1-ODD,2-EVEN; default:0
                            DATA_WIDE = 8            //Data Wide:4,5,6,7,8 bit; default:8bit
)(
    input                           clk     ,
    input                           rst_n   ,
    
    input   [DATA_WIDE - 1 : 0]     din     ,
    input                           din_vld ,
    output                          ready   ,

    output                          uart_txd    
);

//function declare
    function integer clog2b(input integer data);begin 
        data = data - 1;
        for(clog2b = 0;data > 0;clog2b = clog2b + 1)begin
            data = data >> 1;
        end 
    end 
    endfunction

    localparam  BIT_PERIOD = CLK_FREQY / BAUD_RATE          ,//The number of clock cycles  to Tx one bit
                CHK_TYPE   = (CHECK_TYP == "NONE") ? 0 : 
                             (CHECK_TYP == "ODD" ) ? 1 : 
                             (CHECK_TYP == "EVEN") ? 2 : 0  ,
                CNT0_W     = clog2b(BIT_PERIOD)             ,//Count BIT_PERIOD -  1 clock cycles
                CNT1_W     = clog2b(16)                     ;//DATA_WIDE bit to Tx


    localparam  IDLE  = 6'b00_0001,
                START = 6'b00_0010,//Tx Start bit 
                DATA  = 6'b00_0100,//Tx Data bit
                CHECK = 6'b00_1000,//Tx Check bit
                STOP  = 6'b01_0000,//Tx Stop bit
                DONE  = 6'b10_0000;//Tx Done

//Signal declare
    reg     [5 : 0]             state_c                     ;
    reg     [5 : 0]             state_n                     ;

    wire                        idle2start                  ; 
    wire                        start2data                  ; 
    wire                        data2stop                   ; 
    wire                        data2check                  ; 
    wire                        check2stop                  ; 
    wire                        stop2done                   ; 

    reg     [CNT0_W - 1 : 0]    cnt0                        ;//0 ~ BIT_PERIOD - 1
    wire                        add_cnt0                    ;
    wire                        end_cnt0                    ;
    
    reg     [CNT1_W - 1 : 0]    cnt1                        ;//0 ~ xx - 1
    wire                        add_cnt1                    ;
    wire                        end_cnt1                    ;
    reg     [CNT1_W - 1 : 0]    xx                          ;

    reg     [DATA_WIDE - 1 : 0] tx_data                     ;//Latch din 
    reg                         tx_bit                      ;//Tx bit

//FSM
    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            state_c <= IDLE;
        end
        else begin
            state_c <= state_n;
        end
    end

    always @(*)begin
        case(state_c)
            IDLE :state_n = idle2start ? START : state_c;
            START:state_n = start2data ? DATA  : state_c;
            DATA :state_n = data2stop  ? STOP  : (data2check ? CHECK : state_c);
            CHECK:state_n = check2stop ? STOP  : state_c;
            STOP :state_n = stop2done  ? DONE  : state_c;            
            DONE :state_n = IDLE;
            default:state_n = IDLE;
        endcase 
    end
    assign idle2start = state_c == IDLE  && (din_vld);
    assign start2data = state_c == START && (end_cnt1);//Start bit(bit0) Tx done
    assign data2stop  = state_c == DATA  && (CHK_TYPE == 0 && end_cnt1); 
    assign data2check = state_c == DATA  && (CHK_TYPE != 0 && end_cnt1);
    assign check2stop = state_c == CHECK && (end_cnt1);    
    assign stop2done  = state_c == STOP  && (end_cnt1);

    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            cnt0 <= 0;
        end
        else if(add_cnt0)begin
            if(end_cnt0)
                cnt0 <= 0;
            else
                cnt0 <= cnt0 + 1;
        end
    end
    assign add_cnt0 = state_c != IDLE;
    assign end_cnt0 = add_cnt0 && cnt0 == BIT_PERIOD - 1;  

    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            cnt1 <= 0;
        end
        else if(add_cnt1)begin
            if(end_cnt1)
                cnt1 <= 0;
            else
                cnt1 <= cnt1 + 1;
        end
    end
    assign add_cnt1 = end_cnt0;
    assign end_cnt1 = add_cnt1 && cnt1 == xx - 1;   

    always @(*)begin
        if(state_c == START)
            xx = 1;
        else if(state_c == DATA)
            xx = DATA_WIDE;
        else if(state_c == CHECK)
            xx = 1;
        else //if(state_c == STOP)
            xx = STOP_BIT;
    end

    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            tx_data <= 'd0;
        end
        else if(din_vld)begin
            tx_data <= din;
        end
    end

//Tx bit
    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            tx_bit <= 1'b1;
        end
        else begin
            case(state_c)
                START:tx_bit <= 1'b0;
                DATA :tx_bit <= tx_data[cnt1];
                CHECK:tx_bit <= CHK_TYPE == 2 ? (^tx_data) : (~^tx_data);
                STOP :tx_bit <= 1'b1;
                default:tx_bit <= 1'b1;
            endcase 
        end
    end

//Output
    assign uart_txd = tx_bit;
    assign ready    = state_c == IDLE;

endmodule 

module Uart_Rx#(parameter   BAUD_RATE = 115200      ,//Baud Rate:9600,19200,38400,57600,115200,230400; default:115200
                            CLK_FREQY = 50_000_000  ,//System clk; default:50MHz
                            STOP_BIT  = 1           ,//Stop Bit Width:1 bit,2 bit; default:1 bit
                            CHECK_TYP = "NONE"      ,//Parity Check:0-NONE,1-ODD,2-EVEN; default:0
                            DATA_WIDE = 8            //Data Wide:4,5,6,7,8 bit; default:8bit
)(
    input                           clk         ,
    input                           rst_n       ,

    input                           uart_rxd    ,
    output  [DATA_WIDE - 1 : 0]     rx_dout     ,
    output                          rx_dout_vld     
);

 //function declare
    function integer clog2b(input integer data);begin 
        data = data - 1;
        for(clog2b = 0;data > 0;clog2b = clog2b + 1)begin
            data = data >> 1;
        end 
    end 
    endfunction

    localparam  BIT_PERIOD = CLK_FREQY / BAUD_RATE                                                                  ,//The number of clock cycles  to Rx one bit
                RX_WIDE    = (CHECK_TYP == "NONE") ? (DATA_WIDE + 1 + STOP_BIT) : (DATA_WIDE + 1 + 1 + STOP_BIT)    ,//Start bit + Data bit (+ Check bit) + Stop bit
                CHK_TYPE   = (CHECK_TYP == "NONE") ? 0 : (CHECK_TYP == "ODD" ) ? 1 : (CHECK_TYP == "EVEN") ? 2 : 0  ,
                CNT0_W     = clog2b(BIT_PERIOD / 16)                                                                ,//16 times oversampling
                CNT1_W     = clog2b(16)                                                                             ,//16 
                CNT2_W     = clog2b(RX_WIDE)                                                                        ;//RX_WIDE bit to Rx

    localparam  IDLE  = 6'b00_0001,
                START = 6'b00_0010,//Rx Start bit 
                DATA  = 6'b00_0100,//Rx Data bit
                CHECK = 6'b00_1000,//Rx Check bit
                STOP  = 6'b01_0000,//Rx Stop bit
                DONE  = 6'b10_0000;//Rx Done

//signale declare
    reg     [5 : 0]             state_c                     ;
    reg     [5 : 0]             state_n                     ;

    wire                        idle2start                  ; 
    wire                        start2data                  ; 
    wire                        start2idle                  ; 
    wire                        data2stop                   ; 
    wire                        data2check                  ; 
    wire                        check2stop                  ; 
    wire                        stop2done                   ; 

    reg     [CNT0_W - 1 : 0]    cnt0                        ;//0 ~ BIT_PERIOD / 16 - 1
    wire                        add_cnt0                    ;
    wire                        end_cnt0                    ;
    
    reg     [CNT1_W - 1 : 0]    cnt1                        ;//0 ~ 16 - 1
    wire                        add_cnt1                    ;
    wire                        end_cnt1                    ;

    reg     [CNT2_W - 1 : 0]    cnt2                        ;//0 ~ xx - 1
    wire                        add_cnt2                    ;
    wire                        end_cnt2                    ;
    reg     [CNT2_W - 1 : 0]    xx                          ;

    reg     [3 : 0]             oversample_acc              ;//Oversampling accumulator
    reg     [RX_WIDE - 1 : 0]   rx_data                     ;
    reg                         uart_rxd_sync               ;//Sync uart_rxd input
    reg     [1 : 0]             uart_rxd_reg                ;//Register uart_rxd_sync 2 clk cycle
    wire                        uart_rxd_nedge              ;//uart_rxd_sync negedge 
    reg     [DATA_WIDE - 1 : 0] data                        ;//Output rx_dout register
    reg                         data_vld                    ;
    

//FSM
    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            state_c <= IDLE;
        end
        else begin
            state_c <= state_n;
        end
    end

    always @(*)begin
        case(state_c)
            IDLE :state_n = idle2start ? START : state_c;
            START:state_n = start2data ? DATA  : (start2idle ? IDLE  : state_c);
            DATA :state_n = data2stop  ? STOP  : (data2check ? CHECK : state_c);
            CHECK:state_n = check2stop ? STOP  : state_c;
            STOP :state_n = stop2done  ? DONE  : state_c;  
            DONE :state_n = IDLE;
            default:state_n = IDLE;
        endcase 
    end
    assign idle2start = state_c == IDLE  && (uart_rxd_nedge);
    assign start2data = state_c == START && (end_cnt2 && oversample_acc[3] == 1'b0);    //Start bit(bit0) is low,contiue
    assign start2idle = state_c == START && (end_cnt2 && oversample_acc[3] == 1'b1);    //Start bit(bit0) is not low
    assign data2stop  = state_c == DATA  && (CHK_TYPE == 0 && end_cnt2); 
    assign data2check = state_c == DATA  && (CHK_TYPE != 0 && end_cnt2); 
    assign check2stop = state_c == CHECK && (end_cnt2);
    assign stop2done  = state_c == STOP  && (end_cnt2);

    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            cnt0 <= 0;
        end
        else if(add_cnt0)begin
            if(end_cnt0)
                cnt0 <= 0;
            else
                cnt0 <= cnt0 + 1;
        end
    end
    assign add_cnt0 = state_c != IDLE;
    assign end_cnt0 = add_cnt0 && cnt0 == (BIT_PERIOD >> 4) - 1;  

    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            cnt1 <= 0;
        end
        else if(add_cnt1)begin
            if(end_cnt1)
                cnt1 <= 0;
            else
                cnt1 <= cnt1 + 1;
        end
    end
    assign add_cnt1 = end_cnt0;
    assign end_cnt1 = add_cnt1 && cnt1 == 16 - 1;   
    
    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            cnt2 <= 0;
        end
        else if(add_cnt2)begin
            if(end_cnt2)
                cnt2 <= 0;
            else
                cnt2 <= cnt2 + 1;
        end
    end
    assign add_cnt2 = end_cnt1;
    assign end_cnt2 = add_cnt2 && cnt2 == xx - 1;   

    always @(*)begin
        if(state_c == START)
            xx = 1;
        else if(state_c == DATA)
            xx = DATA_WIDE;
        else if(state_c == CHECK)
            xx = 1;
        else //if(state_c == STOP)
            xx = STOP_BIT;
    end

//Sync Register
    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            uart_rxd_sync <= 1'b1;
            uart_rxd_reg  <= 2'b11;
        end
        else begin
            uart_rxd_sync <= uart_rxd;
            uart_rxd_reg  <= {uart_rxd_reg[0],uart_rxd_sync};
        end
    end
    assign uart_rxd_nedge = ~uart_rxd_reg[0] & uart_rxd_reg[1];


//Over sample 
    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            oversample_acc <= 'd0;
        end
        else if(idle2start || end_cnt1)begin //High priority
            oversample_acc <= 'd0;
        end 
        else if(end_cnt0)begin
            case(cnt1)
                3,4,5,6,7,8,9,10,11,12:oversample_acc <= oversample_acc + uart_rxd_reg[1];
                default               :oversample_acc <= oversample_acc;
            endcase
        end
    end

    always @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            rx_data <= 'd0;
        end
        else if(end_cnt1)begin
            rx_data <= {oversample_acc[3],rx_data[RX_WIDE - 1 : 1]};
        end
    end

//Check the result is correct or not
    generate
        case(CHK_TYPE)
            1:begin    //Ji Parity
                always @(posedge clk or negedge rst_n)begin
                    if(~rst_n)begin
                        data_vld <= 1'b0;
                    end
                    else begin
                        data_vld <= state_c == DONE && (^rx_data[1 +: DATA_WIDE + 1]);
                    end
                end
            end 
            2:begin    //Ou Parity    
                always @(posedge clk or negedge rst_n)begin
                    if(~rst_n)begin
                        data_vld <= 1'b0;
                    end
                    else begin
                        data_vld <= state_c == DONE && (~^rx_data[1 +: DATA_WIDE + 1]);
                    end
                end
            end 
            default:begin       //No Parity
                always @(posedge clk or negedge rst_n)begin
                    if(~rst_n)begin
                        data_vld <= 1'b0;
                    end
                    else begin
                        data_vld <= state_c == DONE;
                    end
                end                    
            end
        endcase  

        always @(posedge clk or negedge rst_n)begin
            if(~rst_n)begin
                data <= 'd0;
            end
            else if(state_c == DONE)begin
                data <= rx_data[1 +: DATA_WIDE];
            end
        end


    endgenerate

//Output
    assign rx_dout     = data    ;
    assign rx_dout_vld = data_vld;

endmodule

仿真测试

芯内有乾坤
关注
专栏目录
目标检测YOLO实战应用案例100讲-智能目标检测系统在FPGA中的设计与实现
qq_36130719的博客
06-06 2336
本文结合FPGA芯片的高并行、低功耗、可重配置等优势，对基于卷积神经网络结构的目标检测算法，在端侧场景下的加速与部署进行研究与实现。本章节对本文涉及到的基本理论知识与技术手段进行介绍，为后续系统的方案分析与系统设计奠定理论基础。首先，介绍了卷积神经网络的基本组成部分及其原理。然后，对FPGA及其开发技术进行简单介绍。最后，对当前常用的部分基于FPGA的卷积神经网络加速方法进行概述。
FPGA设计优化（3.5）
qq_43416206的博客
03-17 35
图中，圆圈表示状态，圆圈下的圆角方框对应该状态下的输出。输入是指状态机进入每种状态的条件，有的状态机没有输入条件，其中，状态转移较为简单，有的状态机有输入条件，当某个输入条件存在时，才能转移到相应的状态。为便于说明，我们以一个序列检测器为例，该序列检测器用于检测输入序列是否包含“101”，一旦包含“101”（允许序列重叠，即序列“10101”会被认为包含两个“101”），就将输出置1并保持一个时钟周期，其状态转移图如图8-4所示，图中，圆圈内横线上方为状态名称，横线下方为该状态下对应的输出。
FPGA(二)——基于FPGA的UART收发模块设计
weixin_43361652的博客
08-23 1783
一. UART协议基本原理 二. URAT收发模块的FPGA实现
FPGA-UART
weixin_47936384的博客
01-25 1153
UART作为简单的接口协议，适合开启FPGA的学习之旅。在此基础上延伸出自定义协议，各类FIFO的使用、比较和研究，提炼设计思想，解决时序问题等。
FPGA-UART-全双工串行通信
qq_46303613的博客
03-24 2417
FPGA-停车场计数器 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录FPGA-停车场计数器前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文
使用EGO1的FPGA开发板的基于蓝牙的点阵显示系统设计与实现
挖掘机厨师的博客
12-10 2583
这是作者在大三上学期电子技术课程的课程设计,最终成绩为优秀(95分)
[读书笔记] 用 Verilog 设计 FPGA 样机实例解析 -4.8.2019
Zenor_one的博客
04-08 2279
FPGA Prototyping by Verilog Examples[美]Ping D.Chu[译]李艳志 孟伟 刘军机械工业出版社 中文版 ISBN:9787111536444 分类：可编程逻辑器件-系统设计 配套网站：https://academic.csuohio.edu/chu_p/rtl/fpga_vlog.html 一、门级组合电路 1.标识符，由字母、数字、下划...
FPGA模块总结
Eagle_gqs
04-25 3950
现目前基于FPGA个人所学的模块，觉得重点难点的记录。 包括：状态机、计数器、同步寄存器、边沿捕获、移位寄存器、查找表、分频时钟、串并相互转换、积分器、内部复位、三态门、ADC/DAC、矩阵按键扫描、
CDMA事业部设计开发部电路设计规范
m0_51582169的博客
06-25 713
在现代通信技术的快速发展中，CDMA（码分多址）技术作为一种重要的无线通信技术，广泛应用于移动通信系统中。为了确保CDMA系统的高效稳定运行，设计开发部的电路设计规范至关重要。这篇博客将介绍CDMA事业部设计开发部电路设计规范的主要内容和要点。
uart_test.rar_FPGA verilog_Spartan-6_ise14.7_spartan 6 uart_uart
09-14
在本项目“uart_test.rar”中，开发者使用Verilog硬件描述语言在Spartan-6 FPGA上实现了UART的收发功能，并使用ISE 14.7作为设计工具。以下是对这个项目涉及的知识点的详细解释： 1. **UART协议**： UART是一种...
fpga-verilog-lcd1602-自定义字符 开发技术 - 硬件开发.zip
09-19
在电子硬件设计领域，FPGA（Field-Programmable Gate Array）是一种高度可配置的集成电路，允许设计者根据需求创建自定义...对于学习FPGA设计、嵌入式系统开发或者硬件驱动程序编写的人来说，这是一个宝贵的实践案例。
07_uart_test.zip_fpga_fpga uart_uart_verilog 串口
09-15
总的来说，这个项目提供了一个FPGA实现UART通信的实例，对于学习Verilog和FPGA设计的初学者来说，这是一个很好的实践案例。通过理解UART的工作原理和Verilog代码，可以加深对数字系统设计和通信协议的理解。
计算机研究 -基于DSP和FPGA的多功能嵌入式导航计算机系统设计.pdf
06-26
- **异步串行通讯接口**：设计了多个UART（Universal Asynchronous Receiver/Transmitter, 通用异步收发器）接口，以便与外部设备进行通信。这些接口支持多种波特率设置，增强了系统的兼容性。 - **键盘与LCD接口*...
基于FPGA和UART的乐曲演奏系统设计.pdf
07-13
整体而言，该文件涉及了FPGA技术、UART通信协议以及它们在乐曲演奏系统中的具体应用，提供了硬件开发与调试的实际案例，并强调了FPGA相较于传统技术的优势，对于学习和了解电子系统设计、硬件编程、以及科研项目的...
FPGA远程烧录bit流
FPGA/数字IC/通信算法
09-30 1436
需要注意的是，由于所有命令和数据传输都将通过互联网执行，所有任务（如开发板编程、查看。比如硬件板在实验室或者是其他地方，开发代码与工程在本地计算机，如何将。与科学使用开发工具，大家自行网上搜寻，这边主要说一下如何寻找。进程，但是却显示无设备，此时只需要在远程电脑安装一个驱动。也就是说我们远程的开发板与电脑无需下载完整版本的。后重启远程电脑，连接好。如果能够访问到实验室连接了开发板的电脑的。具备了远程访问开发板的功能。即使能远程连接到实验室电脑的。远程传输至实验室电脑，完成。，即可连接多个开发板。
FPGA时序分析和约束学习笔记（2、FPGA时序传输模型）
qq_37812160的博客
10-05 408
Tsu建立时间：目的寄存器自身的特性决定，在时钟上升沿到达其时钟接口时，其数据输入端（D）的数据必须提前Nns稳定下来，否则就无法确保数据正确存储。Skew时钟偏斜：时钟从源端口出发，到达目的寄存器和源寄存器的时间差值（Tclk2-Tclk1）Slack：数据需求时间和数据到达时间的差值，为正值时数据能被目标寄存器正确接收。Tco输出延时时间：数据输出到Q端口的时间-时钟上升沿到达CLK端口时间。Tclk1：时钟信号从时钟源端口出发，到达源寄存器端口的时间。Tclk1+Tco+Tdata：数据到达时间。
Design Compiler常用命令大总结~
qq_44629558的博客
10-02 416
read_verilog {A.v B.v Top.v} #读取RTL文件current_design Top.v #设置当前设计linkcheck_design #检查RTL代码是否正确。
信号用wire类型还是reg类型定义
最新发布
2302_80790488的博客
10-05 716
总的来说，在模块内部，需要进行什么样的操作，就定义什么类型的信号（wire/reg），在模块外部，定于input端口就使用wire类型，定义ouput端口，原理类似于模块内部，根据信号的操作定义wire或者reg信号。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值