ZYNQ之FPGA学习----UART串口实验

Bertha 。 2023-09-23 16:52 229阅读 0赞

1 UART串口简介

UART串口基础知识学习：硬件设计基础——通信协议UART

2 实验任务

上位机通过串口调试助手发送数据给 Zynq，Zynq PL 端通过 RS232 串口接收数据并将接收到的数据发送给上位机，完成串口数据环回，管脚分配如下：

在这里插入图片描述
图片来自《领航者ZYNQ之FPGA开发指南》

3 实验设计

3.1 创建工程

新建工程，操作如图所示：

在这里插入图片描述

输入工程名字和工程路径，如图：

在这里插入图片描述

选择创建RTL工程，如图：

在这里插入图片描述

直接点击Next：

在这里插入图片描述

继续点击Next：

在这里插入图片描述

添加芯片型号，操作如图：

在这里插入图片描述

完成工程创建：

在这里插入图片描述

3.2 设计输入

创建工程顶层文件，操作如图：

在这里插入图片描述

创建uart_loopback_top顶层模块：

在这里插入图片描述

创建完成：

在这里插入图片描述

双击打开，输入代码如下：

  1. module uart_loopback_top( 
  2.     input           sys_clk,            //外部 50M 时钟 
  3.     input           sys_rst_n,          //外部复位信号，低有效 
  5.     input           uart_rxd,           //UART 接收端口 
  6.     output          uart_txd            //UART 发送端口 
  7.     ); 
  9. //parameter define 
  10. parameter  CLK_FREQ = 50000000;         //定义系统时钟频率 
  11. parameter  UART_BPS = 115200;           //定义串口波特率 
  13. //wire define    
  14. wire       uart_recv_done;              //UART 接收完成 
  15. wire [7:0] uart_recv_data;              //UART 接收数据 
  16. wire       uart_send_en;                //UART 发送使能 
  17. wire [7:0] uart_send_data;              //UART 发送数据 
  18. wire       uart_tx_busy;                //UART 发送忙状态标志 
  20. //串口接收模块      
  21. uart_recv  #(                           
  22.     .CLK_FREQ       (CLK_FREQ ),         //设置系统时钟频率 
  23.     .UART_BPS       (UART_BPS ))         //设置串口接收波特率 
  24. u_uart_recv(                  
  25.     .sys_clk        (sys_clk ),  
  26.     .sys_rst_n      (sys_rst_n ), 
  27.     .uart_rxd       (uart_rxd ), 
  28.     .uart_done      (uart_recv_done ), 
  29.     .uart_data      (uart_recv_data) 
  30.     ); 
  32. //串口发送模块     
  33. uart_send  #(                           
  34.     .CLK_FREQ       (CLK_FREQ ),         //设置系统时钟频率 
  35.     .UART_BPS       (UART_BPS ))         //设置串口发送波特率 
  36. u_uart_send(                  
  37.     .sys_clk        (sys_clk ), 
  38.     .sys_rst_n      (sys_rst_n ), 
  40.     .uart_en        (uart_send_en ), 
  41.     .uart_din       (uart_send_data ), 
  42.     .uart_tx_busy   (uart_tx_busy ), 
  43.     .uart_txd       (uart_txd) 
  44.     ); 
  46. //串口环回模块     
  47. uart_loop u_uart_loop( 
  48.     .sys_clk        (sys_clk ),              
  49.     .sys_rst_n      (sys_rst_n ),            
  51.     .recv_done      (uart_recv_done ),   //接收一帧数据完成标志信号 
  52.     .recv_data      (uart_recv_data ),   //接收的数据 
  53.     .tx_busy        (uart_tx_busy ),     //发送忙状态标志       
  54.     .send_en        (uart_send_en ),     //发送使能信号 
  55.     .send_data      (uart_send_data)    //待发送数据 
  56.     ); 
  58. endmodule

如图所示：

在这里插入图片描述

创建uart_recv文件，如图：

在这里插入图片描述

双击打开，输入代码：

  1. module uart_recv( 
  2.     input             sys_clk,                  //系统时钟 
  3.     input             sys_rst_n,                //系统复位，低电平有效 
  4.     input             uart_rxd,                 //UART 接收端口 
  5.     output   reg       uart_done,                //接收一帧数据完成标志 
  6.     output   reg [7:0] uart_data                 //接收的数据 
  7.     ); 
  9. //parameter define 
  10. parameter  CLK_FREQ = 50000000;                //系统时钟频率 
  11. parameter  UART_BPS = 9600;                    //串口波特率 
  12. localparam  BPS_CNT  = CLK_FREQ/UART_BPS;       //为得到指定波特率， 
  13.                                                //需要对系统时钟计数 BPS_CNT 次 
  14. //reg define 
  15. reg        uart_rxd_d0; 
  16. reg        uart_rxd_d1; 
  17. reg [15:0] clk_cnt;                             //系统时钟计数器 
  18. reg [ 3:0] rx_cnt;                              //接收数据计数器 
  19. reg        rx_flag;                             //接收过程标志信号 
  20. reg [ 7:0] rxdata;                              //接收数据寄存器 
  22. //wire define 
  23. wire       start_flag; 
  25. //捕获接收端口下降沿(起始位)，得到一个时钟周期的脉冲信号 
  26. assign  start_flag = uart_rxd_d1 &  (~uart_rxd_d0 );    
  27. //对 UART 接收端口的数据延迟两个时钟周期 
  28. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin  
  29.     if  (!sys_rst_n)  begin  
  30.         uart_rxd_d0  <= 1'b0; 
  31.         uart_rxd_d1  <= 1'b0;           
  32.     end 
  33.     else  begin 
  34.         uart_rxd_d0   <= uart_rxd;                    
  35.         uart_rxd_d1   <= uart_rxd_d0; 
  36.     end    
  37. end 
  39. //当脉冲信号 start_flag 到达时，进入接收过程            
  40. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin          
  41.     if  (!sys_rst_n)                                   
  42.         rx_flag  <= 1'b0; 
  43.     else  begin 
  44.         if(start_flag)                          //检测到起始位 
  45.            rx_flag  <= 1'b1;                    //进入接收过程，标志位 rx_flag 拉高 
  46.                                                 //计数到停止位中间时，停止接收过程 
  47.         else  if ((rx_cnt  == 4'd9)  && (clk_cnt  == BPS_CNT/2 )) 
  48.             rx_flag  <= 1'b0;                    //接收过程结束，标志位 rx_flag 拉低 
  49.         else 
  50.             rx_flag  <= rx_flag; 
  51.     end 
  52. end 
  54. //进入接收过程后，启动系统时钟计数器 
  55. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin          
  56.     if  (!sys_rst_n)                              
  57.         clk_cnt  <= 16'd0;                                   
  58.     else  if ( rx_flag )  begin                   //处于接收过程 
  59.         if (clk_cnt < BPS_CNT - 1) 
  60.             clk_cnt  <= clk_cnt + 1'b1; 
  61.         else 
  62.             clk_cnt  <= 16'd0;                   //对系统时钟计数达一个波特率周期后清零 
  63.         end 
  64.         else                                             
  65.             clk_cnt  <= 16'd0;                       //接收过程结束，计数器清零 
  66. end
  67. //进入接收过程后，启动接收数据计数器 
  68. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin          
  69.     if  (!sys_rst_n)                              
  70.         rx_cnt   <= 4'd0; 
  71.     else  if ( rx_flag )  begin                   //处于接收过程 
  72.         if (clk_cnt  == BPS_CNT - 1)             //对系统时钟计数达一个波特率周期 
  73.             rx_cnt  <= rx_cnt + 1'b1;            //此时接收数据计数器加 1 
  74.         else 
  75.             rx_cnt  <= rx_cnt;        
  76.     end 
  77.     else 
  78.         rx_cnt   <= 4'd0;                        //接收过程结束，计数器清零 
  79. end 
  81. //根据接收数据计数器来寄存 uart 接收端口数据 
  82. always  @( posedge sys_clk  or negedge sys_rst_n)  begin 
  83.     if ( !sys_rst_n)   
  84.         rxdata  <= 8'd0;                                      
  85.     else  if(rx_flag)                              //系统处于接收过程 
  86.         if (clk_cnt  == BPS_CNT/2)  begin         //判断系统时钟计数器计数到数据位中间 
  87.             case ( rx_cnt ) 
  88.                 4'd1 : rxdata[0]  <= uart_rxd_d1;   //寄存数据位最低位 
  89.                 4'd2 : rxdata[1]  <= uart_rxd_d1; 
  90.                 4'd3 : rxdata[2]  <= uart_rxd_d1; 
  91.                 4'd4 : rxdata[3]  <= uart_rxd_d1; 
  92.                 4'd5 : rxdata[4]  <= uart_rxd_d1; 
  93.                 4'd6 : rxdata[5]  <= uart_rxd_d1; 
  94.                 4'd7 : rxdata[6]  <= uart_rxd_d1; 
  95.                 4'd8 : rxdata[7]  <= uart_rxd_d1;   //寄存数据位最高位 
  96.                 default :;                                     
  97.             endcase 
  98.         end
  99.         else  
  100.             rxdata  <= rxdata; 
  101.     else 
  102.         rxdata  <= 8'd0; 
  103. end
  106. //数据接收完毕后给出标志信号并寄存输出接收到的数据 
  107. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin 
  108.     if  (!sys_rst_n)  begin 
  109.         uart_data  <= 8'd0;                                
  110.         uart_done  <= 1'b0; 
  111.     end 
  112.     else  if(rx_cnt  == 4'd9)  begin               //接收数据计数器计数到停止位时            
  113.         uart_data  <= rxdata;                    //寄存输出接收到的数据 
  114.         uart_done  <= 1'b1;                      //并将接收完成标志位拉高 
  115.     end 
  116.     else  begin 
  117.         uart_data  <= 8'd0;                                    
  118.         uart_done  <= 1'b0;  
  119.     end     
  120. end 
  122. endmodule

如图所示：

在这里插入图片描述

创建uart_send文件，如图所示：

在这里插入图片描述

双击打开文件，输入代码：

  1. module uart_send( 
  2.     input         sys_clk,                  //系统时钟 
  3.     input         sys_rst_n,                //系统复位，低电平有效 
  5.     input         uart_en,                  //发送使能信号 
  6.     input  [7:0]  uart_din,                 //待发送数据 
  7.     output        uart_tx_busy,             //发送忙状态标志       
  8.     output   reg   uart_txd                  //UART 发送端口 
  9.     ); 
  11. //parameter define 
  12. parameter  CLK_FREQ = 50000000;            //系统时钟频率 
  13. parameter  UART_BPS = 9600;                //串口波特率 
  14. localparam  BPS_CNT  = CLK_FREQ/UART_BPS;   //为得到指定波特率，对系统时钟计数 BPS_CNT 次 
  16. //reg define 
  17. reg        uart_en_d0;  
  18. reg        uart_en_d1;   
  19. reg [15:0] clk_cnt;                         //系统时钟计数器 
  20. reg [ 3:0] tx_cnt;                          //发送数据计数器 
  21. reg        tx_flag;                         //发送过程标志信号 
  22. reg [ 7:0] tx_data;                         //寄存发送数据 
  24. //wire define 
  25. wire       en_flag; 
  26. assign uart_tx_busy = tx_flag; 
  28. //捕获 uart_en 上升沿，得到一个时钟周期的脉冲信号 
  29. assign en_flag =  (~uart_en_d1) & uart_en_d0; 
  31. //对发送使能信号 uart_en 延迟两个时钟周期 
  32. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin          
  33.     if  (!sys_rst_n)  begin 
  34.         uart_en_d0  <= 1'b0;
  35.         uart_en_d1  <= 1'b0; 
  36.     end                                                       
  37.     else  begin                                                
  38.         uart_en_d0  <= uart_en;                                
  39.         uart_en_d1  <= uart_en_d0;                             
  40.     end 
  41. end 
  43. //当脉冲信号 en_flag 到达时,寄存待发送的数据，并进入发送过程           
  44. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin          
  45.     if  (!sys_rst_n)  begin                                   
  46.         tx_flag  <= 1'b0; 
  47.         tx_data  <= 8'd0; 
  48.     end  
  49.     else  if (en_flag)  begin                 //检测到发送使能上升沿                       
  50.            tx_flag  <= 1'b1;                //进入发送过程，标志位 tx_flag 拉高 
  51.            tx_data  <= uart_din;            //寄存待发送的数据 
  52.        end 
  53.                                             //计数到停止位结束时，停止发送过程 
  54.        else  if  ((tx_cnt  == 4'd9)  && (clk_cnt  == BPS_CNT -(BPS_CNT/16) ))  begin                                        
  55.            tx_flag  <= 1'b0;                //发送过程结束，标志位 tx_flag 拉低 
  56.            tx_data  <= 8'd0; 
  57.        end 
  58.        else  begin 
  59.            tx_flag  <= tx_flag; 
  60.            tx_data  <= tx_data; 
  61.        end  
  62. end 
  64. //进入发送过程后，启动系统时钟计数器 
  65. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin          
  66.     if  (!sys_rst_n)                              
  67.         clk_cnt  <= 16'd0;                                   
  68.     else  if (tx_flag)  begin                 //处于发送过程 
  69.         if (clk_cnt < BPS_CNT - 1) 
  70.            clk_cnt  <= clk_cnt + 1'b1; 
  71.         else 
  72.            clk_cnt  <= 16'd0;               //对系统时钟计数达一个波特率周期后清零 
  73.     end 
  74.     else                              
  75.        clk_cnt  <= 16'd0;                   //发送过程结束
  76. end 
  78. //进入发送过程后，启动发送数据计数器 
  79. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin          
  80.     if  (!sys_rst_n)                              
  81.         tx_cnt  <= 4'd0; 
  82.     else  if (tx_flag)  begin                 //处于发送过程 
  83.         if (clk_cnt  == BPS_CNT - 1)         //对系统时钟计数达一个波特率周期 
  84.             tx_cnt  <= tx_cnt + 1'b1;        //此时发送数据计数器加 1 
  85.         else 
  86.             tx_cnt  <= tx_cnt;        
  87.         end 
  88.         else                               
  89.             tx_cnt   <= 4'd0;                    //发送过程结束 
  90. end 
  92. //根据发送数据计数器来给 uart 发送端口赋值 
  93. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin         
  94.     if  (!sys_rst_n)   
  95.         uart_txd  <= 1'b1;         
  96.     else  if (tx_flag) 
  97.         case(tx_cnt) 
  98.             4'd0: uart_txd  <= 1'b0;         //起始位  
  99.             4'd1: uart_txd  <= tx_data[0 ];   //数据位最低位 
  100.             4'd2: uart_txd  <= tx_data[1 ]; 
  101.             4'd3: uart_txd  <= tx_data[2 ]; 
  102.             4'd4: uart_txd  <= tx_data[3 ]; 
  103.             4'd5: uart_txd  <= tx_data[4 ]; 
  104.             4'd6: uart_txd  <= tx_data[5 ]; 
  105.             4'd7: uart_txd  <= tx_data[6 ]; 
  106.             4'd8: uart_txd  <= tx_data[7 ];   //数据位最高位 
  107.             4'd9: uart_txd  <= 1'b1;         //停止位 
  108.             default: ; 
  109.         endcase 
  110.     else  
  111.         uart_txd  <= 1'b1;                   //空闲时发送端口为高电平 
  112. end 
  114. endmodule

如图所示：

在这里插入图片描述

创建uart_loop文件，如图所示：

在这里插入图片描述

双击打开，输入代码：

  1. module uart_loop( 
  2.     input             sys_clk,                   //系统时钟 
  3.     input            sys_rst_n,                 //系统复位，低电平有效 
  5.     input            recv_done,                 //接收一帧数据完成标志 
  6.     input      [7:0] recv_data,                 //接收的数据 
  8.     input            tx_busy,                   //发送忙状态标志       
  9.     output  reg       send_en,                   //发送使能信号 
  10.     output  reg [7:0] send_data                  //待发送数据 
  11.     ); 
  13. reg recv_done_d0; 
  14. reg recv_done_d1; 
  15. reg tx_ready; 
  17. wire recv_done_flag;
  18. //捕获 recv_done 上升沿，得到一个时钟周期的脉冲信号 
  19. assign recv_done_flag =  (~recv_done_d1) & recv_done_d0; 
  21. //对发送使能信号 recv_done 延迟两个时钟周期 
  22. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin          
  23.     if  (!sys_rst_n)  begin 
  24.         recv_done_d0  <= 1'b0;                                   
  25.         recv_done_d1  <= 1'b0; 
  26.     end                                                       
  27.     else  begin                                                
  28.         recv_done_d0  <= recv_done;                                
  29.         recv_done_d1  <= recv_done_d0;                             
  30.     end 
  31. end 
  33. //判断接收完成信号，并在串口发送模块空闲时给出发送使能信号 
  34. always  @( posedge sys_clk  or  negedge sys_rst_n)  begin          
  35.     if  (!sys_rst_n)  begin 
  36.         tx_ready   <= 1'b0;  
  37.         send_en    <= 1'b0; 
  38.         send_data  <= 8'd0; 
  39.     end                                                       
  40.     else  begin                                                
  41.         if(recv_done_flag) begin                 //检测串口接收到数据 
  42.             tx_ready   <= 1'b1;                  //准备启动发送过程 
  43.             send_en    <= 1'b0; 
  44.             send_data  <= recv_data;             //寄存串口接收的数据 
  45.         end 
  46.         else  if(tx_ready  &&  (~tx_busy ))  begin   //检测串口发送模块空闲 
  47.             tx_ready  <= 1'b0;                   //准备过程结束
  48.             send_en   <= 1'b1;                   //拉高发送使能信号 
  49.         end 
  50.     end 
  51. end 
  53. endmodule

如图所示：
在这里插入图片描述

3.3 分析与综合

对设计进行分析，操作如图：

在这里插入图片描述

分析后的设计，Vivado自动生成顶层原理图，如图：

在这里插入图片描述

对设计进行综合，操作如图：

在这里插入图片描述

综合完成后，弹出窗口如下，直接关闭：

在这里插入图片描述

3.4 约束输入

创建约束文件，操作如图所示：

在这里插入图片描述

创建约束文件，输入文件名：

在这里插入图片描述
双击打开，输入约束代码：

  1. create_clock -period 20.000 -name clk [get_ports sys_clk] 
  2. set_property -dict {
  3.     PACKAGE_PIN U18 IOSTANDARD LVCMOS33} [get_ports sys_clk] 
  4. set_property -dict {
  5.     PACKAGE_PIN J15 IOSTANDARD LVCMOS33} [get_ports sys_rst_n] 
  6. set_property -dict {
  7.     PACKAGE_PIN J14 IOSTANDARD LVCMOS33} [get_ports uart_rxd] 
  8. set_property -dict {
  9.     PACKAGE_PIN K18 IOSTANDARD LVCMOS33} [get_ports uart_txd]

如图所示：

在这里插入图片描述

3.5 设计实现

点击 Flow Navigator 窗口中的 Run Implementation，如图所示：

在这里插入图片描述

点击OK：

在这里插入图片描述

完成后，直接关闭：

在这里插入图片描述

3.6 功能仿真

创建TestBench，操作如图所示：

在这里插入图片描述

创建激励文件，输入文件名：

在这里插入图片描述

创建完成：

在这里插入图片描述

双击打开，输入TestBench(激励)代码：

  1. `timescale 1ns / 1ps
  2. module tb_uart_loopback_top();
  4. reg    sys_clk;
  5. reg    sys_rst_n;
  6. reg    uart_rxd;
  8. wire    uart_txd;
  10. parameter SYS_CLK = 50;                //系统时钟频率，单位Mhz
  11. parameter SYS_PRE = 1000/(SYS_CLK*2);    //时钟周期，单位ns
  12. parameter UART_BPS = 115200;                //串口波特率
  13. parameter BPS_CNT = 1_000_000_000/UART_BPS;//用于串口仿真的时延
  15. //初始时刻定义
  16. initial  begin 
  17.     $timeformat(-9, 0, " ns", 10);    //定义时间显示格式
  18.     sys_clk = 1'b0; 
  19.     sys_rst_n = 1'b0; 
  20.     uart_rxd <= 1'b1;
  21.     #200 //系统开始工作
  22.     sys_rst_n = 1'b1; 
  24.     #3000
  25.     rx_byte({
  26.     $random} % 256);        //生成8位随机数1
  27.     rx_byte({
  28.     $random} % 256);        //生成8位随机数2
  29.     rx_byte({
  30.     $random} % 256);       //生成8位随机数3
  31.     rx_byte({
  32.     $random} % 256);       //生成8位随机数4
  33.     rx_byte({
  34.     $random} % 256);        //生成8位随机数5
  35.     rx_byte({
  36.     $random} % 256);        //生成8位随机数6
  37.     rx_byte({
  38.     $random} % 256);       //生成8位随机数7
  39.     rx_byte({
  40.     $random} % 256);       //生成8位随机数8
  41.     #600
  42.     $finish();
  43. end
  45. //定义任务，每次发送的数据10 位(起始位1+数据位8+停止位1)
  46. task rx_byte(
  47.     input [7:0] data
  48. );
  49.     integer i; //定义一个常量
  50.     //用 for 循环产生一帧数据，for 括号中最后执行的内容只能写 i=i+1
  51.     for(i=0; i<10; i=i+1) begin
  52.         case(i)
  53.         0: uart_rxd <= 1'b0;        //起始位
  54.         1: uart_rxd <= data[0];        //LSB
  55.         2: uart_rxd <= data[1];
  56.         3: uart_rxd <= data[2];
  57.         4: uart_rxd <= data[3];
  58.         5: uart_rxd <= data[4];
  59.         6: uart_rxd <= data[5];
  60.         7: uart_rxd <= data[6];
  61.         8: uart_rxd <= data[7];        //MSB
  62.         9: uart_rxd <= 1'b1;        //停止位
  63.         endcase
  64.         #BPS_CNT;                         //每发送 1 位数据延时
  65.     end        
  66. endtask                             //任务结束
  68. //设置主时钟
  69. always #10 sys_clk <= ~sys_clk;        //时钟20ns,50M
  70. //例化被测试的串口接收驱动
  72. //例化被测试的串口接收驱动
  73. uart_loopback_top
  74. #(
  75.     .UART_BPS            (UART_BPS),        
  76.     .SYS_CLK           (SYS_CLK)            
  77. )
  78. u_uart_loopback_top(
  79.     .sys_clk        (sys_clk),
  80.     .sys_rst_n        (sys_rst_n),
  81.     .uart_rxd        (uart_rxd),
  82.     .uart_txd        (uart_txd)    
  83. );
  85. endmodule

如图所示：

在这里插入图片描述

开始进行仿真，操作如下：

在这里插入图片描述

开始仿真，仿真波形如图：

在这里插入图片描述

选择需要观察的HDL仿真对象，波形如图：

在这里插入图片描述

3.7 下载验证

由于疫情，一直无法去实验室，故ZYNQ开发板不在身边，该步骤内容待更新

致谢领航者ZYNQ开发板，开启FPGA学习之路！

希望本文对大家有帮助，上文若有不妥之处，欢迎指正

分享决定高度，学习拉开差距

发表评论

表情：
评论列表 （有 0 条评论，229人围观）

还没有评论，来说两句吧...

相关阅读