devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于FPGA的UART接口设计_基于fpga的uart接口的设计

作者：秋刀鱼在做梦 | 2024-08-09 07:29:42

赞

踩

基于fpga的uart接口的设计

 一、顶层设计思路：

        UART即通用异步收发传输接口（Universal Asynchronous Receiver/Transmitter），简称串口，是一种常用的通信接口，其协议原理就不赘述了，不了解的可以自己查阅资料。（不赘述不代表不重要，相反，对于每一个FPGA设计，充分理解原理是基础和前提，而FPGA和Verilog只是工具。）用FPGA来实现UART，关键就是要将UART收发数据时的时序用Verilog描述出来。

        根据UART协议的原理，可以将整个UART分为两个模块：串口接收模块“UART_RX”和串口发送模块“UART_TX”，前者将接收到的1位串行数据“uart_rxd”转化为8位并行数据“data[7:0]”，后者又将8位并行数据“data[7:0]”转化回1位串行数据“uart_txd”输出，最终实现串行数据的收发。UART顶层功能框图如图1所示：

图1 

二、串口接收模块设计思路：

        该模块实现将接收到的1位串行数据转化为8位并行数据，而只有当有数据输入时，该模块才去工作，所以需要一个使能信号“rxd_en”来控制该模块，当“rxd_en”有效时，该模块才工作。根据UART协议原理，接收到的1位串行数据最开始的一位为起始位（“0”），而“uart_rxd”在空闲时为“1”，故刚开始接收到串行数据时，“uart_rxd”必定会产生一个下降沿，所以可以检测这个下降沿，每当下降沿到来的同时将“rxd_en”置为有效，从而使该模块开始工作；每当所有串行数据都被接收完毕时，再把“rxd_en”置为无效，同时发出接收完成标志“rx_done”，从而关闭该模块。（关于在Verilog里怎么实现实现边沿检测，可以看我写的关于DDS信号发生器的那篇博文。）

        在数据接收的过程中，速率以串口波特率为准，常用的串口波特率有：1200、2400、4800、9600、14400、57600、115200等等。所以需要一个波特率计数器“baud_cnt”在特定的波特率下对主时钟进行计数，每当这个波特率计数器计满时，接收一位数据。例如，主时钟为50MHz，当波特率为9600时，波特率计数器的最大值应该为：50000000/9600-1=5207，此时，每当波特率计数器计到5207时就清零，同时接收一位串行数据。

        在本次设计中，每个数据的数据位共有10位（1位起始位、8位数据位、1位停止位），故在接收过程中，还需要一个位计数器“bit_cnt”来对每个串行数据的数据位进行计数，具体操作为：每当波特率计数器计满时，位计数器就自增1，直到位计数器的值为9时清零。

        在接收过程中，为了接收到稳定的串行数据，本设计在每一位串行数据的中间对其进行采样和接收，具体操作为：每当波特率计数器计到最大值的一半时，就对当前的串行数据进行采样，然后根据位计数器的值，将采样后的值赋给相应的并行数据位。此外，为了消除亚稳态，待接收的串行数据应该先通过一个两位的寄存器进行缓冲后再进行边沿检测。

        根据以上分析，做出串口接收模块的时序图如图2所示（“uart_rxd_r”是“uart_rxd”消除亚稳态后再通过边沿检测寄存器后的信号）：

图2

        根据时序图，就可以进行串口接收模块的RTL描述，编写的Verilog代码如下：

  1. `timescale 1ns / 1ps
  2.  
  3. module UART_RX(
  4.     input clk, //主时钟，50MHz
  5.     input rst, //复位，高电平有效
  6.     input uart_tx_data, //发送给串口的串行数据
  7.     
  8.     output reg [7:0] uart_rx_data, //串口接收后的并行数据
  9.     output reg rx_done //接收完成标志
  10.     );
  11.     
  12.     parameter CLK_F = 50000000; //主时钟频率
  13.     parameter UART_B = 9600; //串口波特率
  14.     parameter B_CNT = CLK_F / UART_B; //波特率计数器的最大值
  15.     
  16.     reg [1:0] uart_tx_data_r1; //用于消除输入串行数据的亚稳态
  17.     reg [1:0] uart_tx_data_r2; //输入串行数据边沿检测寄存器
  18.     reg rxd_en; //接收使能信号
  19.     reg [15:0] baud_cnt = 16'd0; //115200波特率计数器
  20.     reg [3:0] bit_cnt = 4'd0; //位计数器
  21.     reg [7:0] rx_data; //接收数据寄存器
  22.  
  23.     
  24. /***************消除输入串行数据亚稳态*************/
  25.     always @ (posedge clk)
  26.     begin
  27.         uart_tx_data_r1 <= {uart_tx_data_r1[0] , uart_tx_data};
  28.     end
  29.  
  30. /***************输入串行数据边沿检测*************/
  31.     always @ (posedge clk)
  32.     begin
  33.         uart_tx_data_r2 <= {uart_tx_data_r2[0] , uart_tx_data_r1[1]};
  34.     end
  35.  
  36. /***************接收使能信号控制*************/
  37.     always @ (posedge clk or negedge rst)
  38.     begin
  39.         if (rst)
  40.             rxd_en <= 1'd0;
  41.         else
  42.         begin 
  43.             if (uart_tx_data_r2 == 2'b10)
  44.                 rxd_en <= 1'd1;
  45.             else if ((bit_cnt == 4'd9) && (baud_cnt == B_CNT / 2))
  46.                 rxd_en <= 1'd0;
  47.             else 
  48.                 rxd_en <= rxd_en;
  49.         end
  50.     end
  51.  
  52. /***************波特率计数器控制*************/
  53.     always @ (posedge clk or negedge rst)
  54.     begin
  55.         if (rst)
  56.             baud_cnt <= 16'd0;
  57.         else if (rxd_en)
  58.         begin
  59.             if (baud_cnt == B_CNT - 1)
  60.                 baud_cnt <= 16'd0;
  61.             else
  62.                 baud_cnt <= baud_cnt + 1'b1;
  63.         end
  64.         else
  65.             baud_cnt <= 16'd0;
  66.     end
  68. /***************位计数器控制*************/
  69.     always @ (posedge clk or negedge rst)
  70.     begin
  71.         if (rst)
  72.             bit_cnt <= 4'd0;
  73.         else if (rxd_en)
  74.         begin
  75.             if (baud_cnt == B_CNT - 1)
  76.                 bit_cnt <= bit_cnt + 1'b1;
  77.             else
  78.                 bit_cnt <= bit_cnt;
  79.         end
  80.         else
  81.             bit_cnt <= 4'd0;
  82.     end
  83.  
  84. /***************接收缓存*************/
  85.     always @ (posedge clk or negedge rst)
  86.     begin
  87.         if (rst)
  88.             rx_data <= 8'd0;
  89.         else if (rxd_en)
  90.         begin
  91.             if (baud_cnt == B_CNT / 2)
  92.             begin
  93.                 case (bit_cnt)
  94.                     4'd1:rx_data[0] <= uart_tx_data_r2[1];
  95.                     4'd2:rx_data[1] <= uart_tx_data_r2[1];
  96.                     4'd3:rx_data[2] <= uart_tx_data_r2[1];
  97.                     4'd4:rx_data[3] <= uart_tx_data_r2[1];
  98.                     4'd5:rx_data[4] <= uart_tx_data_r2[1];
  99.                     4'd6:rx_data[5] <= uart_tx_data_r2[1];
  100.                     4'd7:rx_data[6] <= uart_tx_data_r2[1];
  101.                     4'd8:rx_data[7] <= uart_tx_data_r2[1];
  102.                     default:;
  103.                 endcase
  104.             end
  105.             else
  106.                 rx_data <= rx_data;
  107.         end
  108.         else
  109.             rx_data <= 8'd0;
  110.     end
  111.  
  112. /***************接收*************/
  113.     always @ (posedge clk or negedge rst)
  114.     begin
  115.         if (rst)
  116.             uart_rx_data <= 8'd0;
  117.         else if (bit_cnt == 4'd9)
  118.             uart_rx_data <= rx_data;
  119.         else
  120.             uart_rx_data <= 8'd0;
  121.     end
  123. /***************接收完成标志控制*************/
  124.     always @ (posedge clk or negedge rst)
  125.     begin
  126.         if (rst)
  127.             rx_done <= 1'd0;
  128.         else if (bit_cnt == 4'd9)
  129.             rx_done <= 1'd1;
  130.         else
  131.             rx_done <= 1'd0;
  132.     end
  133.     
  134. endmodule

        编写的testbeach如下：

  1. `timescale 1ns / 1ps
  2.  
  3. module tb_uart_rx();
  4.  
  5.     reg clk; //主时钟，50MHz
  6.     reg rst; //复位，低电平有效
  7.     reg uart_tx_data; //发送给串口的串行数据
  8.     
  9.     wire [7:0] uart_rx_data; //串口接收后的并行数据
  10.     wire rx_done; //接收完成标志
  11.    
  12. /***************模块例化*************/ 
  13.     UART_RX tb_uart_rx(
  14.         .clk(clk),      
  15.         .rst(rst),     
  16.         .uart_tx_data(uart_tx_data), 
  17.                              
  18.         .uart_rx_data(uart_rx_data), 
  19.         .rx_done(rx_done)  
  20.     );
  21.  
  22. /***************产生主时钟*************/
  23.     always #10 clk = ~clk;
  24.     
  25. /***************初始化*************/
  26.     initial 
  27.     begin
  28.         clk = 1'd0;
  29.         rst = 1'd0;
  30.         uart_tx_data = 1'b1;
  31.         #1000000
  32.         uart_tx_data = 1'b0;
  33.         #200000
  34.         uart_tx_data = 1'b1;
  35.         #200000
  36.         uart_tx_data = 1'b0;
  37.         #200000
  38.         uart_tx_data = 1'b1;
  39.     end
  40.    
  41. endmodule

         仿真结果如图3所示，可以看到接收功能已实现：

图3 

三、串口发送模块设计思路：

        该模块实现将8位并行数据转化回1位串行数据输出，与接收模块一样，串口发送模块也需要一个使能信号“txd_en”来控制，当“txd_en”有效时，模块才工作。根据UART原理，只有接收模块接收完成后，发送模块才能开始工作，故接收模块里的接收完成标志即是发送模块的发送开始标志“txd_start”，所以可以通过检测发送开始标志的上升沿来使能“txd_en”，从而使能发送模块。

        根据以上分析，做出串口发送模块的时序图如图4所示：

 图4

        根据时序图，编写的Verilog代码如下：

  1. `timescale 1ns / 1ps
  2.  
  3. module UART_TX(
  4.     input clk, //主时钟，50MHz
  5.     input rst, //复位，高电平有效
  6.     input txd_start, //发送开始标志
  7.     input [7:0] uart_rx_data, //串口接收到的并行数据
  8.     
  9.     output reg uart_tx_data //串口发送的串行数据
  10.     );
  11.     
  12.     parameter CLK_F = 50000000; //主时钟频率
  13.     parameter UART_B = 9600; //串口波特率
  14.     parameter B_CNT = CLK_F / UART_B; //波特率计数器的最大值
  15.     
  16.     reg [1:0] txd_start_r; //发送开始标志边沿检测寄存器 
  17.     reg txd_en; //发送使能信号
  18.     reg [15:0] baud_cnt = 16'd0; //115200波特率计数器
  19.     reg [3:0] bit_cnt = 4'd0; //位计数器
  20.     reg [7:0] tx_data; //发送数据寄存器
  21.  
  22. /***************发送开始标志边沿检测*************/
  23.     always @ (posedge clk)
  24.     begin
  25.         txd_start_r <= {txd_start_r[0] , txd_start};
  26.     end
  27.     
  28. /***************发送使能信号控制*************/
  29.     always @ (posedge clk or negedge rst)
  30.     begin
  31.         if (rst)
  32.             txd_en <= 1'd0;
  33.         else
  34.         begin 
  35.             if (txd_start_r == 2'b01)
  36.                 txd_en <= 1'd1;
  37.             else if ((bit_cnt == 4'd9) && (baud_cnt == B_CNT / 2))
  38.                 txd_en <= 1'd0;
  39.             else 
  40.                 txd_en <= txd_en;
  41.         end
  42.     end
  43.     
  44. /***************发送缓存*************/
  45.     always @ (posedge clk or negedge rst)
  46.     begin
  47.         if (rst)
  48.             tx_data <= 8'd0;
  49.         else
  50.         begin 
  51.             if (txd_start_r == 2'b01)
  52.                 tx_data <= uart_rx_data;
  53.             else if ((bit_cnt == 4'd9) && (baud_cnt == B_CNT / 2))
  54.                 tx_data <= 8'd0;
  55.             else 
  56.                 tx_data <= tx_data;
  57.         end
  58.     end
  59.     
  60. /***************波特率计数器控制*************/
  61.     always @ (posedge clk or negedge rst)
  62.     begin
  63.         if (rst)
  64.             baud_cnt <= 16'd0;
  65.         else if (txd_en)
  66.         begin
  67.             if (baud_cnt == B_CNT - 1)
  68.                 baud_cnt <= 16'd0;
  69.             else
  70.                 baud_cnt <= baud_cnt + 1'b1;
  71.         end
  72.         else
  73.             baud_cnt <= 16'd0;
  74.     end
  76. /***************位计数器控制*************/
  77.     always @ (posedge clk or negedge rst)
  78.     begin
  79.         if (rst)
  80.             bit_cnt <= 4'd0;
  81.         else if (txd_en)
  82.         begin
  83.             if (baud_cnt == B_CNT - 1) 
  84.                 bit_cnt <= bit_cnt + 1'b1;
  85.             else
  86.                 bit_cnt <= bit_cnt;
  87.         end
  88.         else
  89.             bit_cnt <= 4'd0;
  90.     end
  91.  
  92. /***************发送*************/
  93.     always @ (posedge clk or negedge rst)
  94.     begin
  95.         if (rst)
  96.             uart_tx_data <= 1'd1;
  97.         else if (txd_en)
  98.         begin
  99.             case (bit_cnt)
  100.                 4'd0:uart_tx_data <= 1'd0;
  101.                 4'd1:uart_tx_data <= tx_data[0];
  102.                 4'd2:uart_tx_data <= tx_data[1];
  103.                 4'd3:uart_tx_data <= tx_data[2];
  104.                 4'd4:uart_tx_data <= tx_data[3];
  105.                 4'd5:uart_tx_data <= tx_data[4];
  106.                 4'd6:uart_tx_data <= tx_data[5];
  107.                 4'd7:uart_tx_data <= tx_data[6];
  108.                 4'd8:uart_tx_data <= tx_data[7];
  109.                 4'd9:uart_tx_data <= 1'd1;
  110.                 default:;
  111.             endcase
  112.         end
  113.         else
  114.             uart_tx_data <= 1'd1;
  115.     end
  116.     
  117. endmodule

        编写的testbeach如下：

  1. `timescale 1ns / 1ps
  2.  
  3. module tb_uart_tx();
  4.  
  5.     reg clk; //主时钟，50MHz
  6.     reg rst; //复位，低电平有效
  7.     reg txd_start; //发送开始标志
  8.     reg [7:0] uart_rx_data; //串口接收到的并行数据
  9.     
  10.     wire uart_tx_data; //串口发送的串行数据
  11.    
  12. /***************模块例化*************/ 
  13.     UART_TX tb_uart_tx(
  14.         .clk(clk),      
  15.         .rst(rst),     
  16.         .txd_start(txd_start),    
  17.         .uart_rx_data(uart_rx_data), 
  18.                              
  19.         .uart_tx_data(uart_tx_data)
  20.     );
  21.  
  22. /***************产生主时钟*************/
  23.     always #10 clk = ~clk;
  24.     
  25. /***************初始化*************/
  26.     initial 
  27.     begin
  28.         clk = 1'd0;
  29.         rst = 1'd0;
  30.         txd_start = 1'd0;
  31.         uart_rx_data = 8'h5a;
  32.         #20
  33.         txd_start = 1'd1;
  34.         #20
  35.         txd_start = 1'd0;
  36.         #100000
  37.         uart_rx_data = 8'h3f;
  38.         #100000
  39.         uart_rx_data = 8'he6;
  40.     end
  41.    
  42. endmodule

          仿真结果如图5所示，可以看到发送功能已实现：

图5

四、顶层代码及其上板调试：

        两个子模块设计完成后，按照顶层功能框图可以编写顶层的RTL描述，编写的Verilog代码如下（由于我的开发板上的时钟是差分时钟，故需要调用一个差分信号转单端信号的设计原语“IBUFDS”，该原语的使用很简单，在这里就不专门介绍了，不了解的可以自己查阅资料）：

  1. `timescale 1ns / 1ps
  2.  
  3. module UART_TOP(
  4.     input clk_p, //差分主时钟正端，50MHz
  5.     input clk_n, //差分主时钟负端，50MHz
  6.     input rst, //复位，高电平有效
  7.     input uart_rxd, //接收端
  8.     
  9.     output uart_txd //发送端
  10.     );
  11.     
  12.     parameter  CLK_FREQ = 50000000; //主时钟频率
  13.     parameter  UART_BPS = 460800; //串口波特率
  14.     
  15.     wire clk; //主时钟，50MHz
  16.     wire [7:0] uart_rx_data_w; //串口里的并行数据线
  17.     wire rx_done_w; //接收完成信号线
  18.  
  19. /***************差分时钟转单端时钟*************/
  20.     IBUFDS #(
  21.           .DIFF_TERM("FALSE"), 
  22.           .IBUF_LOW_PWR("TRUE"), 
  23.           .IOSTANDARD("DEFAULT") 
  24.        ) IBUFDS_inst (
  25.           .O(clk), 
  26.           .I(clk_p), 
  27.           .IB(clk_n)
  28.        );
  29.     
  30. /***************调用串口接收模块*************/
  31.     UART_RX #(
  32.     .CLK_F(CLK_FREQ),
  33.     .UART_B(UART_BPS)
  34.     )
  35.     uut_rxd(
  36.         .clk(clk),
  37.         .rst(rst),
  38.         .uart_tx_data(uart_rxd),
  39.         .uart_rx_data(uart_rx_data_w),
  40.         .rx_done(rx_done_w)
  41.     );
  42.     
  43. /***************调用串口发送模块*************/
  44.     UART_TX #(
  45.     .CLK_F(CLK_FREQ), 
  46.     .UART_B(UART_BPS)
  47.     )
  48.     uut_txd(
  49.         .clk(clk),
  50.         .rst(rst),
  51.         .txd_start(rx_done_w),
  52.         .uart_rx_data(uart_rx_data_w),
  53.         .uart_tx_data(uart_txd) 
  54.     );
  55.      
  56. endmodule

        综合、实现后，进行上板调试，为了简单起见，本设计采用回环的方式来调试验证，即PC发送数据到FPGA上，FPGA通过串口接收数据后再通过串口发送回PC。调试结果如图6所示，可以看到，所设计的串口工作正常：

图6

        至此，本设计完成。 

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

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号