UART串口通信实验
5 e, Y  m. o+ R串口是“串行接口”的简称，即采用串行通信方式的接口。串行通信将数据字节分成一位一位的形式在一条数据线上逐个传送，其特点是通信线路简单，但传输速度较慢。因此串口广泛应用于嵌入式、工业控制等领域中对数据传输速度要求不高的场合。本章我们将使用ZYNQ开发板上的UART串口完成上位机与ZYNQ PL的通信。

16.1 UART串口简介
8 [2 r. _  \  i' W$ J2 f串行通信分为两种方式：同步串行通信和异步串行通信。同步串行通信需要通信双方在同一时钟的控制下，同步传输数据；异步串行通信是指通信双方使用各自的时钟控制数据的发送和接收过程。
UART是一种采用异步串行通信方式的通用异步收发传输器（universal asynchronous receiver-transmitter），它在发送数据时将并行数据转换成串行数据来传输，在接收数据时将接收到的串行数据转换成并行数据。
UART串口通信需要两根信号线来实现，一根用于串口发送，另外一根负责串口接收。UART在发送或接收过程中的一帧数据由4部分组成，起始位、数据位、奇偶校验位和停止位，如图 7.5.13.1所示。其中，起始位标志着一帧数据的开始，停止位标志着一帧数据的结束，数据位是一帧数据中的有效数据。校验位分为奇校验和偶校验，用于检验数据在传输过程中是否出错。奇校验时，发送方应使数据位中1的个数与校验位中1的个数之和为奇数；接收方在接收数据时，对1的个数进行检查，若不为奇数，则说明数据在传输过程中出了差错。同样，偶校验则检查1的个数是否为偶数。
1 g# o. I. Z3 g0 G. \
* w  b! y- t1 `# p  p; W# j

图 7.5.13.1 异步串行通信数据格式
8 t" Q# E4 x2 w( r8 cUART通信过程中的数据格式及传输速率是可设置的，为了正确的通信，收发双方应约定并遵循同样的设置。数据位可选择为5、6、7、8位，其中8位数据位是最常用的，在实际应用中一般都选择8位数据位；校验位可选择奇校验、偶校验或者无校验位；停止位可选择1位（默认），1.5或2位。串口通信的速率用波特率表示，它表示每秒传输二进制数据的位数，单位是bps（位/秒），常用的波特率有9600、19200、38400、57600以及115200等。
在设置好数据格式及传输速率之后，UART负责完成数据的串并转换，而信号的传输则由外部驱动电路实现。电信号的传输过程有着不同的电平标准和接口规范，针对异步串行通信的接口标准有RS232、RS422、RS485等，它们定义了接口不同的电气特性，如RS-232是单端输入输出，而RS-422/485为差分输入输出等。
/ m1 o) Y+ ~8 KRS232接口标准出现较早，可实现全双工工作方式，即数据发送和接收可以同时进行。在传输距离较短时（不超过15m），RS232是串行通信最常用的接口标准，本章主要介绍针对RS-232标准的UART串口通信。
RS-232标准的串口最常见的接口类型为DB9，样式如图 7.5.13.2所示，工业控制领域中用到的工控机一般都配备多个串口，很多老式台式机也都配有串口。但是笔记本电脑以及较新一点的台式机都没有串口，它们一般通过USB转串口线（图 7.5.13.3）来实现与外部设备的串口通信。


' L: l2 f+ m' ^# h
) \: w0 D  r1 o5 h7 L7 f/ v图 7.5.13.2 DB9接口
* F. [5 R# O4 o$ ]1 o' m. I, K
/ M5 G$ B8 d6 H1 h

1 H) J# W0 T/ F2 d) e图 7.5.13.3 USB串口线
DB9接口定义以及各引脚功能说明如图 7.5.13.4所示，我们一般只用到其中的2（RXD）、3（TXD）、5（GND）引脚，其他引脚在普通串口模式下一般不使用，如果大家想了解，可以自行百度下。


4 t% L9 Y3 W* x; k6 T$ a
6 I0 ~0 P% o5 U4 {( a图 7.5.13.4 DB9接口定义
16.2 实验任务
本节实验任务是上位机通过串口调试助手发送数据给Zynq，Zynq PL端通过RS232串口接收数据并将接收到的数据发送给上位机，完成串口数据环回。
$ C; j/ b. T0 g; D
* e/ @6 G& o4 a7 X$ b8 e3 y16.3 硬件设计
领航者ZYNQ开发板上RS232串口部分的原理图如下所示：
8 d, L; z0 d: x! e3 z& r
+ `0 S" h8 {# [3 X% d7 v; s, [

' {; M& r$ T2 ^  h# |; u图 7.5.13.1 领航者RS232串口原理图
由于ZYNQ PL端串口输入输出引脚为TTL电平，用3.3V代表逻辑“1”，0V代表逻辑“0”；而计算机串口采用RS-232电平，它是负逻辑电平，即-15V-5V代表逻辑“1”，+5V+15V代表逻辑“0”。因此当计算机与ZYNQ通信时，需要加电平转换芯片SP3232，实现RS232电平与TTL电平的转换。
从图 7.5.13.1中可以看到，SP3232芯片端口的U2_RX和U2_TX并没有直接和ZYNQ的引脚相连接，而是连接到了P1排针上。RS232串口和RS485串口共用P1排针的UART2_TX和UART2_RX，而UART2_TX和UART2_RX是直接和ZYNQ的引脚相连接的。在使用时，使用跳线帽选择与ZYNQ相连接的串口类型，这样的设计方式实现了有限IO的复用。因此，在做RS232的通信实验时，需要使用杜邦线或者跳线帽将U2_RX和UART2_TX连接在一起，U2_TX和UART2_RX连接在一起。
' u% K- T( f1 c7 |2 B1 u+ S2 x/ \: O1 |本实验中，系统时钟、按键复位以及串口的接收、发送端口的管脚分配如下表所示：
表 16.3.1 串口通信实验管脚分配
" K" B$ a% t7 n; d/ \" u  _信号名 方向 管脚 端口说明 电平标准
4 P: a$ d6 [& n# Q0 q- t: Z* jsys_clk input U18 系统时钟，50M LVCMOS33
  b) ~: O0 u$ o/ |sys_rst_n input N16 系统复位，低有效 LVCMOS33
uart_rxd input K14 串口接收 LVCMOS33
uart_txd output M15 串口发送 LVCMOS33
$ Z- Q! U4 a* I1 M' U4 z对应的XDC约束语句如下所示：
9 N/ n. u9 `  K- e% L6 a
4 i. O/ `, G  E* l

1. create_clock -period 20.000 -name clk [get_ports sys_clk]
   ) F" r  f0 K& T( h+ [0 O
2. set_property -dict {PACKAGE_PIN U18 IOSTANDARD LVCMOS33} [get_ports sys_clk]
   * x5 E- \8 \& L, O8 C5 ]( a
3. set_property -dict {PACKAGE_PIN N16 IOSTANDARD LVCMOS33} [get_ports sys_rst_n]
   ; f$ y/ M( S' t( g  y
4. set_property -dict {PACKAGE_PIN K14 IOSTANDARD LVCMOS33} [get_ports uart_rxd]
   ' G$ h6 _4 T) p7 c3 P
5. set_property -dict {PACKAGE_PIN M15 IOSTANDARD LVCMOS33} [get_ports uart_txd]

复制代码

5 `; K! y0 }, T& H& m0 T5 F16.4 程序设计
7 U+ |. B" I! e- o根据实验任务，我们不难想象本系统应该有一个串口接收模块，用来接收上位机发送的数据；还要有一个串口发送模块，用于将数据发回上位机；另外还应该有一个对数据进行环回控制的模块，它负责把从串口接收模块接收到的数据送给串口发送模块，以实现串口数据的环回。由此可以画出本次实验的系统框图，如下所示：
% T8 r7 A1 X# F8 b/ M, _

' d4 J+ S" C4 h/ W5 r- N$ S
图 7.5.13.1 系统框图
由系统总体框图可知，ZYNQ PL部分包括四个模块，顶层模块、接收模块、发送模块和数据环回模块。其中在顶层模块中完成对另外三个模块的例化，顶层模块原理图如下所示：
/ e$ @0 d. A$ n% }+ O/ u

- o6 B7 i+ J+ ~5 D5 U/ L
8 v6 u- F. u5 A9 v# X$ p图 7.5.13.2 顶层模块原理图
在图 7.5.13.2中，uart_recv为串口接收模块，从串口接收端口uart_rxd来接收上位机发送的串行数据，并在一帧数据接收结束后给出通知信号uart_done。
uart_send为串口发送模块，以uart_en为发送使能信号。uart_en的上升沿将启动一次串口发送过程，将uart_din接口上的数据通过串口发送端口uart_txd发送出去。
1 g: f6 U) r6 O- j' y1 Euart_loop模块负责完成串口数据的环回功能。它在uart_recv模块接收完成后，将接收到的串口数据发送到uart_send模块，并通过send_en接口给出一个上升沿，以启动发送过程。
/ m1 o$ O3 @/ t$ u在编写代码之前，我们首先要确定串口通信的数据格式及波特率。在这里我们选择串口比较常用的一种模式，数据位为8位，停止位为1位，无校验位，波特率为115200bps。则传输一帧数据的时序图如下图所示：

' ~8 J% k& h8 p
* k* P2 E5 f2 i# j5 S2 E
( X. z5 f; L: y; E# W0 M图 7.5.13.3 串口通信时序图
& S' ^) w) `" K: e$ K. V顶层模块的代码如下：
, M  T6 P$ K- P9 N( `3 p* {

1. 1  module uart_loopback_top(
   3 R- T/ \2 e3 T# \6 O
2. 2      input           sys_clk,            //外部50M时钟
   
3. 3      input           sys_rst_n,          //外部复位信号，低有效
   
4. 4  
   $ k& F! W( Y/ L5 x% A% p
5. 5      input           uart_rxd,           //UART接收端口
   0 l. j; x( T5 l. g# S/ r
6. 6      output          uart_txd            //UART发送端口
   
7. 7      );
   - i1 b; E. M4 a/ [* x% N/ k+ m
8. 8  
   
9. 9  //parameter define
   
10. 10 parameter  CLK_FREQ = 50000000;         //定义系统时钟频率
    1 R3 o6 S) U5 s$ S
11. 11 parameter  UART_BPS = 115200;           //定义串口波特率
    3 q/ Q& a0 i7 j
12. 12     
    
13. 13 //wire define   
    
14. 14 wire       uart_recv_done;              //UART接收完成
    
15. 15 wire [7:0] uart_recv_data;              //UART接收数据
    0 H  L- N* ~* Y# c3 L# M* ?& y
16. 16 wire       uart_send_en;                //UART发送使能
    2 M0 Q9 Y3 z3 J3 y: Y( C- @
17. 17 wire [7:0] uart_send_data;              //UART发送数据
    
18. 18 wire       uart_tx_busy;                //UART发送忙状态标志
    9 |: H5 `( ?3 L" [3 e- ^
19. 19
    3 r8 X+ ]' L9 L% h$ o# @
20. 20 //*****************************************************
    
21. 21 //**                    main code
    $ n* s6 _, {1 g
22. 22 //*****************************************************
    
23. 23
    ; o; t+ e/ _( }; J- R. U
24. 24 //串口接收模块     
    
25. 25 uart_recv #(                          
    
26. 26     .CLK_FREQ       (CLK_FREQ),         //设置系统时钟频率
    * c: a: B) A5 |  P& L4 L1 \" d$ W
27. 27     .UART_BPS       (UART_BPS))         //设置串口接收波特率
    
28. 28 u_uart_recv(                 
    $ s, w$ w, b! b, m. @" G
29. 29     .sys_clk        (sys_clk),
    
30. 30     .sys_rst_n      (sys_rst_n),
    
31. 31     
    . T4 ~- O2 x/ J5 Q7 g
32. 32     .uart_rxd       (uart_rxd),
    
33. 33     .uart_done      (uart_recv_done),
    
34. 34     .uart_data      (uart_recv_data)
    % i- H' e8 h: T3 l0 _( D3 B& g
35. 35     );
    1 f% ^1 i9 k6 F) e
36. 36
    
37. 37 //串口发送模块   
    
38. 38 uart_send #(                          
    
39. 39     .CLK_FREQ       (CLK_FREQ),         //设置系统时钟频率
    3 z+ [  a7 C6 E0 r. L  S
40. 40     .UART_BPS       (UART_BPS))         //设置串口发送波特率
    : M: I7 j/ A4 O4 t- N0 X# {
41. 41 u_uart_send(                 
    1 \0 J+ I0 o5 A9 W3 S# \4 z$ r
42. 42     .sys_clk        (sys_clk),
    9 p; Y  Z; @* K; {, B  e& G
43. 43     .sys_rst_n      (sys_rst_n),
    
44. 44      
    ( B2 k# O( G2 c* ?
45. 45     .uart_en        (uart_send_en),
    
46. 46     .uart_din       (uart_send_data),
    3 u% g% l6 G* w# L' m
47. 47     .uart_tx_busy   (uart_tx_busy),
    
48. 48     .uart_txd       (uart_txd)
    
49. 49     );
    
50. 50     
    8 C7 A# H0 N5 ^6 o' `+ t1 p4 M1 K9 m
51. 51 //串口环回模块   
    - r6 g! s. J  }) T' }5 {
52. 52 uart_loop u_uart_loop(
    
53. 53     .sys_clk        (sys_clk),            
    3 G' l2 v5 L3 b) k/ W# u6 P" z
54. 54     .sys_rst_n      (sys_rst_n),           
    $ |7 K7 Q# J9 l0 l) c
55. 55   
    
56. 56     .recv_done      (uart_recv_done),   //接收一帧数据完成标志信号
    - y- b6 ?% e( Y- Y; q6 |
57. 57     .recv_data      (uart_recv_data),   //接收的数据
    4 ?3 R' [0 l( B: M( n+ e
58. 58   
    
59. 59     .tx_busy        (uart_tx_busy),     //发送忙状态标志      
    
60. 60     .send_en        (uart_send_en),     //发送使能信号
    
61. 61     .send_data      (uart_send_data)    //待发送数据
    
62. 62     );
    0 s0 L( k% B$ _" V, `8 a) w
63. 63     
    ( ]# J! k$ b* D' R7 N" ?' g
64. 64 endmodule

复制代码

在顶层模块中完成了对其余各个子模块的例化。需要注意的是，顶层模块中第10、11行定义了两个变量：系统时钟频率CLK_FREQ与串口波特率UART_BPS，使用时可以根据不同的系统时钟频率以及所需要的串口波特率设置这两个变量。我们可以尝试将串口波特率UART_BPS设置为其他值（如9600），在模块例化时会将这个变量传递到串口接收与发送模块中，从而实现不同速率的串口通信。
串口接收模块的代码如下所示：
+ Q* m2 C' c) h& |' c' g

1. 1   module uart_recv(
   
2. 2       input             sys_clk,                  //系统时钟
   ; q6 T3 {5 W  p# I5 B0 ^
3. 3       input             sys_rst_n,                //系统复位，低电平有效
     ^2 x4 R8 @$ G: b  f9 o
4. 4      
   
5. 5       input             uart_rxd,                 //UART接收端口
   & {" j( y4 S* h, P9 y' _% f2 C
6. 6       output  reg       uart_done,                //接收一帧数据完成标志
   & {9 y5 {6 K) h& @
7. 7       output  reg [7:0] uart_data                 //接收的数据
   
8. 8       );
   
9. 9      
   
10. 10  //parameter define
    : F+ |, @) }& b; o( w
11. 11  parameter  CLK_FREQ = 50000000;                //系统时钟频率
    * F  j. y& b" i# ?# ]
12. 12  parameter  UART_BPS = 9600;                    //串口波特率
    , m6 x" z* N; _
13. 13  localparam  BPS_CNT  = CLK_FREQ/UART_BPS;       //为得到指定波特率，
    1 Y: m  T+ ^, q+ @& L
14. 14                                                  //需要对系统时钟计数BPS_CNT次
    
15. 15  //reg define
    
16. 16  reg        uart_rxd_d0;
    
17. 17  reg        uart_rxd_d1;
      {0 Z0 j" e$ e. r) f
18. 18  reg [15:0] clk_cnt;                             //系统时钟计数器
    1 H6 N+ h+ M$ q0 g; D
19. 19  reg [ 3:0] rx_cnt;                              //接收数据计数器
    * O" j* s9 E* p& E
20. 20  reg        rx_flag;                             //接收过程标志信号
    
21. 21  reg [ 7:0] rxdata;                              //接收数据寄存器
    & o% a. S5 m: {" P
22. 22  
    
23. 23  //wire define
    
24. 24  wire       start_flag;
    
25. 25  
    
26. 26  //*****************************************************
    0 w; U/ M+ }' T$ Q7 L
27. 27  //**                    main code
    
28. 28  //*****************************************************
    
29. 29  //捕获接收端口下降沿(起始位)，得到一个时钟周期的脉冲信号
    9 h( H7 l3 l& a  Z$ n& J. W
30. 30  assign  start_flag = uart_rxd_d1 & (~uart_rxd_d0);   
    
31. 31  
    
32. 32  //对UART接收端口的数据延迟两个时钟周期
    
33. 33  always @(posedge sys_clk or negedge sys_rst_n) begin
    5 W. x$ C8 u1 X0 F& Y7 H
34. 34      if (!sys_rst_n) begin
    
35. 35          uart_rxd_d0 <= 1'b0;
    
36. 36          uart_rxd_d1 <= 1'b0;         
    
37. 37      end
    
38. 38      else begin
    
39. 39          uart_rxd_d0  <= uart_rxd;                  
    
40. 40          uart_rxd_d1  <= uart_rxd_d0;
    
41. 41      end   
    , w( o; f2 \; P# _6 T
42. 42  end
    1 V' j* o7 T* M& a5 ^
43. 43  
    ( M; ]( P! B& x# a0 I% u
44. 44  //当脉冲信号start_flag到达时，进入接收过程           
    # n3 i6 K; z4 o8 ]' U
45. 45  always @(posedge sys_clk or negedge sys_rst_n) begin         
    
46. 46      if (!sys_rst_n)                                 
    
47. 47          rx_flag <= 1'b0;
    
48. 48      else begin
    
49. 49          if(start_flag)                          //检测到起始位
    
50. 50              rx_flag <= 1'b1;                    //进入接收过程，标志位rx_flag拉高
    
51. 51                                                  //计数到停止位中间时，停止接收过程
    
52. 52          else if((rx_cnt == 4'd9) && (clk_cnt == BPS_CNT/2))
    # z. B3 o5 d% e+ d5 @: R$ H" H/ j, y1 k
53. 53              rx_flag <= 1'b0;                    //接收过程结束，标志位rx_flag拉低
    ) q7 ^7 ?+ L* {1 {
54. 54          else
    # P7 A# r* u# r& ~
55. 55              rx_flag <= rx_flag;
    
56. 56      end
    
57. 57  end
    $ l$ \1 T) E& s. L# w
58. 58  
      q; e2 Q3 d% {" g, H
59. 59  //进入接收过程后，启动系统时钟计数器
    5 H/ `+ ~' P5 ^$ c
60. 60  always @(posedge sys_clk or negedge sys_rst_n) begin         
    2 d4 v6 A. n7 q" ?; Q
61. 61      if (!sys_rst_n)                             
    
62. 62          clk_cnt <= 16'd0;                                 
    
63. 63      else if ( rx_flag ) begin                   //处于接收过程
    
64. 64          if (clk_cnt < BPS_CNT - 1)
    
65. 65              clk_cnt <= clk_cnt + 1'b1;
    9 s* E3 W7 l' v% @! [" U
66. 66          else
    % H9 F# }& N9 U7 Z, Q9 }
67. 67              clk_cnt <= 16'd0;                   //对系统时钟计数达一个波特率周期后清零
    
68. 68      end
    3 p" J6 r3 Z& S6 y
69. 69      else                                            
    
70. 70          clk_cnt <= 16'd0;                       //接收过程结束，计数器清零
    4 H* b0 }) A* i! t1 w
71. 71  end
    6 H; A4 r" i" s1 d; n. E
72. 72  
    
73. 73  //进入接收过程后，启动接收数据计数器
    4 x7 I( W. F+ n; n9 x* p# j
74. 74  always @(posedge sys_clk or negedge sys_rst_n) begin         
    
75. 75      if (!sys_rst_n)                             
    - i+ z: y1 x8 ?8 X: ?6 m
76. 76          rx_cnt  <= 4'd0;
    
77. 77      else if ( rx_flag ) begin                   //处于接收过程
    # g# ^( N3 m7 q, P' P
78. 78          if (clk_cnt == BPS_CNT - 1)             //对系统时钟计数达一个波特率周期
    : y0 }& i* {* l8 o% C4 A3 w- `8 o
79. 79              rx_cnt <= rx_cnt + 1'b1;            //此时接收数据计数器加1
    " m7 E3 T+ t, K2 N, ]& d
80. 80          else
    " r% k, z8 |5 K! o2 a
81. 81              rx_cnt <= rx_cnt;      
    
82. 82      end
    
83. 83       else
    
84. 84          rx_cnt  <= 4'd0;                        //接收过程结束，计数器清零
    
85. 85  end
    
86. 86  
    : Z3 a! |6 o; \) q
87. 87  //根据接收数据计数器来寄存uart接收端口数据
    4 l% B2 Y5 c+ K
88. 88  always @(posedge sys_clk or negedge sys_rst_n) begin
    
89. 89      if ( !sys_rst_n)  
    
90. 90          rxdata <= 8'd0;                                    
    " Q/ i0 N' M1 C4 S" p5 W
91. 91      else if(rx_flag)                            //系统处于接收过程
    
92. 92          if (clk_cnt == BPS_CNT/2) begin         //判断系统时钟计数器计数到数据位中间
    7 ?- \8 g/ J" R! Y  `
93. 93              case ( rx_cnt )
      ~' O; L7 m- r2 z
94. 94               4'd1 : rxdata[0] <= uart_rxd_d1;   //寄存数据位最低位
    
95. 95               4'd2 : rxdata[1] <= uart_rxd_d1;
    2 n( \$ Y) d! r/ F8 S7 }, N
96. 96               4'd3 : rxdata[2] <= uart_rxd_d1;
    
97. 97               4'd4 : rxdata[3] <= uart_rxd_d1;
    % W& y# Q9 b4 B2 S5 o" a
98. 98               4'd5 : rxdata[4] <= uart_rxd_d1;
    
99. 99               4'd6 : rxdata[5] <= uart_rxd_d1;
    - r( A; [8 _7 A# T$ x( U6 x6 j
100. 100              4'd7 : rxdata[6] <= uart_rxd_d1;
     1 E& `2 ^% J9 E  {$ G0 d
101. 101              4'd8 : rxdata[7] <= uart_rxd_d1;   //寄存数据位最高位
     , a0 R1 ]* D9 Y! V* p. @
102. 102              default:;                                    
     ! k$ Z/ W5 S9 e9 Q! B+ ]
103. 103             endcase
     
104. 104         end
     ) O; @% L  y) e0 B
105. 105         else
     
106. 106             rxdata <= rxdata;
     : P% n6 _5 G0 K! ]
107. 107     else
     9 H; w9 A2 G1 _; M( v: h# [# M* U! C
108. 108         rxdata <= 8'd0;
     
109. 109 end
     ; A" w. y* ~  W1 c, V3 t& q# }
110. 110
     ! o' \( q' ]: J5 T
111. 111 //数据接收完毕后给出标志信号并寄存输出接收到的数据
     ' C7 [6 r# [6 z4 ~5 ?: l
112. 112 always @(posedge sys_clk or negedge sys_rst_n) begin        
     $ N$ j# m0 f1 b0 L
113. 113     if (!sys_rst_n) begin
     3 n0 B7 i0 S1 K' }& u  ]
114. 114         uart_data <= 8'd0;                              
     7 G! q! A! O( t: Q1 c) r
115. 115         uart_done <= 1'b0;
     
116. 116     end
     
117. 117     else if(rx_cnt == 4'd9) begin               //接收数据计数器计数到停止位时           
     - Q/ c1 C$ c! T6 Y' O
118. 118         uart_data <= rxdata;                    //寄存输出接收到的数据
     - h2 s+ A$ w+ A# y% z3 B" D2 |5 |
119. 119         uart_done <= 1'b1;                      //并将接收完成标志位拉高
     
120. 120     end
     $ a3 d, m1 D" K9 u0 r" d* T
121. 121     else begin
     / r; W" ~8 g, l! \
122. 122         uart_data <= 8'd0;                                   
     
123. 123         uart_done <= 1'b0;
     
124. 124     end   
     # ]  O+ G0 U+ t  m# Z
125. 125 end
     / D, q" a4 n( K- E
126. 126
     ) Q  X% @; x7 L' F
127. 127 endmodule

复制代码

串口接收模块程序中29至42行是一个经典的边沿检测电路，通过检测串口接收端uart_rxd的下降沿来捕获起始位。一旦检测到起始位，输出一个时钟周期的脉冲start_flag，并进入串口接收过程。串口接收状态用rx_flag来标志，rx_flag为高标志着串口接收过程正在进行，此时启动系统时钟计数器clk_cnt与接收数据计数器rx_cnt。
! S' }0 v& e! h  j. I. v7 x由第13行的公式BPS_CNT = CLK_FREQ/UART_BPS可知，BPS_CNT为当前波特率下，串口传输一位所需要的系统时钟周期数。因此clk_cnt从零计数到BPS_CN-1时，串口刚好完成一位数据的传输。由于接收数据计数器rx_cnt在每次clk_cnt计数到BPS_CN-1时加1，因此由rx_cnt的值可以判断串口当前传输的是第几位数据。第87行至第109行就是根据clk_cnt的值将uart接收端口的数据寄存到接收数据寄存器对应的位，从而实现接收数据的串并转换。其中第92行选择clk_cnt计数至BPS_CNT/2时寄存接收端口数据，是因为计数到数据中间时的采样结果最稳定。
程序中需要额外注意的地方是串口接收过程结束条件的判定，由第52行可知，在计数到停止位中间时，标志位rx_flag就已经拉低。这样做是因为虽然此时一帧数据传输还没有完成（停止位只传送到一半），但是数据位已经寄存完毕。而在连续接收数据时，提前半个波特率周期结束接收过程可以为检测下一帧数据的起始位留出充足的时间。
( S/ U; w# m) w& `/ h0 o. U9 W( V我们使用上位机通过串口向开发板发送16进制数55，在串口接收过程中ILA抓取的波形图如下所示：
, n; p4 ?0 s5 O& S* ^: k% X# {1 B$ Z0 u; A

' ?* b5 r' i' a% \
图 7.5.13.4 串口接收过程波形图
  V) ^8 x. R! r* @+ [图 7.5.13.4中红色的触发线标识出了串口接收端uart_rxd的起始位，在整个接收过程中rx_flag保持为高电平，同时rx_cnt对串口数据进行计数。当rx_cnt计数到９时，串口数据接收完成，uart_done拉高，同时uart_data给出接收到的数据。从图中可以看到，接收模块能够正确接收串口数据并完成串并转换。
/ w, ?: G) L+ [5 S6 d% E  G/ f串口发送模块代码如下所示：
( T9 O+ m! i: Q4 ]4 b' C
% ?- Z' V4 K4 D' S  \4 W7 T

1. 1   module uart_send(
   * h; o# ]; [8 C
2. 2       input         sys_clk,                  //系统时钟
   
3. 3       input         sys_rst_n,                //系统复位，低电平有效
   . Z, w% T) G6 p$ K9 ^1 p
4. 4      
   ) N! y& ^% e- ~' y  u
5. 5       input         uart_en,                  //发送使能信号
   
6. 6       input  [7:0]  uart_din,                 //待发送数据
   ' _' i4 c. S% V; k" Y) F
7. 7       output        uart_tx_busy,             //发送忙状态标志      
   
8. 8       output  reg   uart_txd                  //UART发送端口
   
9. 9       );
   
10. 10      
    ! Y8 s2 j8 e$ p" s9 y6 s' \
11. 11  //parameter define
    
12. 12  parameter  CLK_FREQ = 50000000;            //系统时钟频率
      t2 W5 x% {+ v
13. 13  parameter  UART_BPS = 9600;                //串口波特率
    , `$ B+ X* l2 C- H
14. 14  localparam  BPS_CNT  = CLK_FREQ/UART_BPS;   //为得到指定波特率，对系统时钟计数BPS_CNT次
    6 _6 }" N: D- W) j6 V! Z1 J4 j
15. 15  
    
16. 16  //reg define
    
17. 17  reg        uart_en_d0;
    
18. 18  reg        uart_en_d1;  
    
19. 19  reg [15:0] clk_cnt;                         //系统时钟计数器
    
20. 20  reg [ 3:0] tx_cnt;                          //发送数据计数器
    + \& r2 Q# _, f8 |* c( g( M
21. 21  reg        tx_flag;                         //发送过程标志信号
    + j( W; G6 [% O) q* ?4 w* z: a$ P
22. 22  reg [ 7:0] tx_data;                         //寄存发送数据
    & w4 x6 c- i0 ^
23. 23  
    
24. 24  //wire define
    
25. 25  wire       en_flag;
    
26. 26  
    ! a& G; X7 ~; S
27. 27  //*****************************************************
    # h7 S, E9 Q, G0 _4 u7 W- Y8 g% A
28. 28  //**                    main code
    ! R) n# M! B( H
29. 29  //*****************************************************
    & j8 d4 Y3 X9 b
30. 30  //在串口发送过程中给出忙状态标志
    ! z# s: ]1 r1 Y3 c6 s  ?) \
31. 31  assign uart_tx_busy = tx_flag;
    * K4 _  G$ a7 z9 x1 V
32. 32  
    2 Q  v# `  l6 O# A8 x2 ?
33. 33  //捕获uart_en上升沿，得到一个时钟周期的脉冲信号
    / w/ O2 I3 q  Q, Z4 M2 ^# ^
34. 34  assign en_flag = (~uart_en_d1) & uart_en_d0;
    
35. 35  
    ; s6 ?. c" H8 Q$ P; m
36. 36  //对发送使能信号uart_en延迟两个时钟周期
    
37. 37  always @(posedge sys_clk or negedge sys_rst_n) begin         
    9 ?3 v8 Y; J. X8 @
38. 38      if (!sys_rst_n) begin
    
39. 39          uart_en_d0 <= 1'b0;                                 
    7 t8 r# I6 y( S& M# N
40. 40          uart_en_d1 <= 1'b0;
    
41. 41      end                                                      
    
42. 42      else begin                                               
    
43. 43          uart_en_d0 <= uart_en;                              
    
44. 44          uart_en_d1 <= uart_en_d0;                           
    
45. 45      end
    ' F0 T, p3 p5 p8 X$ o5 U1 B/ L
46. 46  end
    
47. 47  
    
48. 48  //当脉冲信号en_flag到达时,寄存待发送的数据，并进入发送过程         
    
49. 49  always @(posedge sys_clk or negedge sys_rst_n) begin         
    : K' K. a2 K0 B1 n
50. 50      if (!sys_rst_n) begin                                 
    
51. 51          tx_flag <= 1'b0;
    0 @, d3 m& n. {% C
52. 52          tx_data <= 8'd0;
    7 @: W- B2 c" ?1 y( X7 Y
53. 53      end
    
54. 54      else if (en_flag) begin                 //检测到发送使能上升沿                     
    
55. 55              tx_flag <= 1'b1;                //进入发送过程，标志位tx_flag拉高
    
56. 56              tx_data <= uart_din;            //寄存待发送的数据
    
57. 57          end
    - F3 ^/ L; N. q- o" F6 s
58. 58                                              //计数到停止位结束时，停止发送过程
    " `! y* f" C7 f& S5 b! A
59. 59          else if ((tx_cnt == 4'd9) && (clk_cnt == BPS_CNT -(BPS_CNT/16))) begin                                       
    6 l3 l3 V6 R5 a5 y+ ?: s6 U' @$ C
60. 60              tx_flag <= 1'b0;                //发送过程结束，标志位tx_flag拉低
    
61. 61              tx_data <= 8'd0;
    
62. 62          end
    ! u3 E6 k. l4 B3 N
63. 63          else begin
    & f, t! E- o& B7 h$ u; h, B  s
64. 64              tx_flag <= tx_flag;
    . R2 q+ D% v& z4 ~( R0 P2 w- r7 Z
65. 65              tx_data <= tx_data;
    
66. 66          end
    6 I- T% [& \; S7 j! M! b* \
67. 67  end
    
68. 68  
    3 P' o9 ?0 q! X
69. 69  //进入发送过程后，启动系统时钟计数器
    7 A) e/ T& ^6 `9 P
70. 70  always @(posedge sys_clk or negedge sys_rst_n) begin         
    : }  ]7 r7 A& t7 T
71. 71      if (!sys_rst_n)                             
    
72. 72          clk_cnt <= 16'd0;                                 
    
73. 73      else if (tx_flag) begin                 //处于发送过程
    * R3 T" ]  O: e! D5 F/ }: u2 C
74. 74          if (clk_cnt < BPS_CNT - 1)
    # D& \( A+ q4 r5 @# B: S
75. 75              clk_cnt <= clk_cnt + 1'b1;
    7 I+ G: E1 K1 d" j' X
76. 76          else
    
77. 77              clk_cnt <= 16'd0;               //对系统时钟计数达一个波特率周期后清零
    ( v' V1 t1 t- @! i0 v! ?: z
78. 78      end
    
79. 79      else                             
    & v* i; W' c% F
80. 80          clk_cnt <= 16'd0;                   //发送过程结束
    
81. 81  end
    6 M* e  T0 z- ^
82. 82  
    
83. 83  //进入发送过程后，启动发送数据计数器
    
84. 84  always @(posedge sys_clk or negedge sys_rst_n) begin         
    
85. 85      if (!sys_rst_n)                             
    " n5 |1 |% G- Z) Z  T: l3 v
86. 86          tx_cnt <= 4'd0;
    
87. 87      else if (tx_flag) begin                 //处于发送过程
    
88. 88          if (clk_cnt == BPS_CNT - 1)         //对系统时钟计数达一个波特率周期
    , s1 w  ?2 H1 K, z& Z" o4 [
89. 89              tx_cnt <= tx_cnt + 1'b1;        //此时发送数据计数器加1
    
90. 90          else
    
91. 91              tx_cnt <= tx_cnt;      
    
92. 92      end
    
93. 93      else                              
    - f% [  ?0 _. I& j( |3 e: l" ^
94. 94          tx_cnt  <= 4'd0;                    //发送过程结束
    
95. 95  end
    
96. 96  
    
97. 97  //根据发送数据计数器来给uart发送端口赋值
    
98. 98  always @(posedge sys_clk or negedge sys_rst_n) begin        
    . p" J1 d- H& L8 k, {! u6 V: M* S
99. 99      if (!sys_rst_n)  
    8 O; |: q$ Q1 R' x
100. 100         uart_txd <= 1'b1;        
     + Q$ j- l  q0 G+ s
101. 101     else if (tx_flag)
     
102. 102         case(tx_cnt)
     " R: J; ~" b: Q' b+ d0 W. g
103. 103             4'd0: uart_txd <= 1'b0;         //起始位
     - v- f9 \* S# _5 |' p
104. 104             4'd1: uart_txd <= tx_data[0];   //数据位最低位
     
105. 105             4'd2: uart_txd <= tx_data[1];
     
106. 106             4'd3: uart_txd <= tx_data[2];
     
107. 107             4'd4: uart_txd <= tx_data[3];
     
108. 108             4'd5: uart_txd <= tx_data[4];
     5 c) F$ B: P$ Q! q$ J$ R
109. 109             4'd6: uart_txd <= tx_data[5];
     $ {5 }& R2 `0 D" s% r  [' O  g
110. 110             4'd7: uart_txd <= tx_data[6];
     * q9 a$ }4 [# a; T% P
111. 111             4'd8: uart_txd <= tx_data[7];   //数据位最高位
     
112. 112             4'd9: uart_txd <= 1'b1;         //停止位
     
113. 113             default: ;
       d' p& g5 _# @3 G4 D$ J9 k
114. 114         endcase
     
115. 115     else
     $ J3 Q3 q/ y( R
116. 116         uart_txd <= 1'b1;                   //空闲时发送端口为高电平
     * j5 }/ `6 L9 m8 j6 @: y/ }$ F8 }
117. 117 end
     & V  b$ D4 J  K: J$ N3 I( r/ ]0 D
118. 118
     , p/ r/ E6 l# p* C
119. 119 endmodule  

复制代码

$ Z3 U. P. g( F7 W3 V串口发送模块与串口接收模块异曲同工，代码中也给出了详尽的注释，此处不再赘述。需要注意的是，在程序的59行，我们将tx_flag提前1/16个停止位拉低，是为了确保发送模块发送数据的时间略小于接收模块接收数据的时间，否则当连续传输大量数据时，发送数据的时间会不断累积，最终导致在做串口环回实验时丢失数据。
( |) \! J% i3 s$ M! Q2 @3 Q5 ]. r# b尽管串口发送数据只是接收数据的反过程，理论上在传输的时间上是一致的，考虑到我们模块里计算波特率会有较小的偏差，并且串口对端的通信设备(如电脑等)收发数据的波特率同样可能会出现较小的偏差，因此这里为了确保环回实验的成功，这里将发送模块的停止位略微提前结束。
( w' o2 b, @* W/ X* C需要说明的是，较小偏差的波特率在串口通信时是允许的，同样可以保证数据可靠稳定的传输。
另外我们在代码的第31行将用于标志串口发送过程的tx_flag信号赋值给uart_tx_busy，并通过模块端口输出。这样其他模块就可以通过检测uart_tx_busy信号是否为低电平，从而判断串口发送模块是否处于空闲状态。若uart_tx_busy为高电平，那么uart_send正处于发送过程，外部模块需要等待当前发送过程结束之后，才能通过uart_en信号的上升沿来启动新的发送过程。
图 7.5.13.5为串口发送过程中ILA抓取的波形图，我们使用开发板通过串口向上位机向发送16进制数55。图中绿色的触发线标识出了串口发送使能信号uart_en的上升沿。在检测到uart_en的上升沿后，en_flag会拉高一个时钟周期，此时将uart_din端口上的待发送数据寄存到tx_data中，并进入串口发送过程。
在整个发送过程中tx_flag保持为高电平，tx_cnt对串口数据进行计数，同时tx_data的各个数据位依次通过串口发送端uart_txd发送出去。当tx_cnt计数到９时，串口数据发送完成，开始发送停止位。在一个波特率周期的停止位发送完成后，串口发送过程结束，uart_tx_busy信号拉低，表明串口发送模块进入空闲状态。
6 |% u4 ?% F" u% u' P
0 i2 ~: ~" `1 j- B

1 R3 Z# Y  G2 c8 E图 7.5.13.5 串口发送过程波形图
从图 7.5.13.5中可以看出串口发送模块能够完成并串转换并正确发送串口数据。
8 F/ \1 s9 ^6 Z. E. ~$ n% ]8 a在介绍完串口的接收和发送模块后，最后我们来看一下串口环回模块的代码：
  `; P( P% R) u6 w3 s0 g" p) v

1. 1  module uart_loop(
   
2. 2      input             sys_clk,                   //系统时钟
   
3. 3      input            sys_rst_n,                 //系统复位，低电平有效
   
4. 4      
   
5. 5      input            recv_done,                 //接收一帧数据完成标志
   9 t! R4 q, b6 H% N1 s" G
6. 6      input      [7:0] recv_data,                 //接收的数据
   4 D! I8 o2 _3 j
7. 7      
   
8. 8      input            tx_busy,                   //发送忙状态标志      
   
9. 9      output reg       send_en,                   //发送使能信号
   0 [1 f8 `* @' m& }+ K
10. 10     output reg [7:0] send_data                  //待发送数据
    
11. 11     );
    & X7 n# L- f( g! Z  u! Y! M" o- K
12. 12
    * o+ R" D5 Y) I9 O6 C. T& u8 J/ n$ S
13. 13 //reg define
    ( G4 I* L4 u0 _- {: y
14. 14 reg recv_done_d0;
    
15. 15 reg recv_done_d1;
    0 g: m$ N2 G4 y4 D4 ]
16. 16 reg tx_ready;
    
17. 17
    + w' ]+ e3 k" C& Z/ E# v8 F
18. 18 //wire define
    
19. 19 wire recv_done_flag;
    % ^' u$ @& ^( _' {
20. 20
    
21. 21 //*****************************************************
    4 y2 K/ Q( d3 N9 t3 W
22. 22 //**                    main code
    4 _+ L  ~9 Z' Q4 B, A* [: a6 M3 T
23. 23 //*****************************************************
    
24. 24
    
25. 25 //捕获recv_done上升沿，得到一个时钟周期的脉冲信号
    
26. 26 assign recv_done_flag = (~recv_done_d1) & recv_done_d0;
    ( d' c! ~/ E( P% B
27. 27                                                  
    
28. 28 //对发送使能信号recv_done延迟两个时钟周期
    0 W! l7 m# r4 e& c# l# Y: q
29. 29 always @(posedge sys_clk or negedge sys_rst_n) begin         
    
30. 30     if (!sys_rst_n) begin
      ?/ o$ K+ |( Y) n& n
31. 31         recv_done_d0 <= 1'b0;                                 
    
32. 32         recv_done_d1 <= 1'b0;
    
33. 33     end                                                      
    
34. 34     else begin                                               
    
35. 35         recv_done_d0 <= recv_done;                              
    & g- v4 l/ j) d
36. 36         recv_done_d1 <= recv_done_d0;                           
      [9 O! V2 R. B8 i3 P8 m
37. 37     end
    
38. 38 end
    4 k. @4 M/ @- x/ ]
39. 39
    
40. 40 //判断接收完成信号，并在串口发送模块空闲时给出发送使能信号
    
41. 41 always @(posedge sys_clk or negedge sys_rst_n) begin         
    
42. 42     if (!sys_rst_n) begin
    
43. 43         tx_ready  <= 1'b0;
    
44. 44         send_en   <= 1'b0;
    
45. 45         send_data <= 8'd0;
    
46. 46     end                                                      
    
47. 47     else begin                                               
    
48. 48         if(recv_done_flag)begin                 //检测串口接收到数据
    6 u) V0 N1 {4 I. E
49. 49             tx_ready  <= 1'b1;                  //准备启动发送过程
    8 M5 ?) m% ^' g* g6 \! J
50. 50             send_en   <= 1'b0;
    $ U5 d! _9 i3 h- R+ ^3 e& X
51. 51             send_data <= recv_data;             //寄存串口接收的数据
    % O$ M+ P, j0 f
52. 52         end
    3 ?6 [5 U+ X& f" v$ l( [
53. 53         else if(tx_ready && (~tx_busy)) begin   //检测串口发送模块空闲
    
54. 54             tx_ready <= 1'b0;                   //准备过程结束
    
55. 55             send_en  <= 1'b1;                   //拉高发送使能信号
    + w$ y. E9 ?- s
56. 56         end
    1 x+ j2 z, R% W& l$ c) W
57. 57     end
    & M( a4 s3 A4 Y# R
58. 58 end
    
59. 59
    
60. 60 endmodule

复制代码

. t' \6 t2 b; [/ a$ zuart_loop模块的代码比较简单，首先代码的25至38行实现了上升沿检测功能。当检测到recv_done信号的上升沿时，recv_done_flag输出一个时钟周期的高电平，标志着串口接收模块接收到了一帧数据。在代码的48至52行，在判断到recv_done_flag为高电平时，寄存接收到的数据recv_data到send_data中；同时将tx_ready信号拉高，表示已经准备好了待发送的数据。另外还要将send_en信号拉低，为接下来产生一个上升沿作准备。
* S6 N/ {3 C: H3 G% @uart_loop模块还有一个输入信号tx_busy，它是由串口发送模块所输出，该信号为高电平表示串口发送模块正处于发送过程中。在代码的第53行，当tx_ready信号为高电平时，如果检测到tx_busy为低电平，则说明串口发送模块处于空闲状态。此时将send_en信号拉高，由此产生一个上升沿，以启动串口发送模块的发送过程，将寄存到send_data中的数据发送出去。于此同时，将tx_ready信号拉低，等待下一个串口接收数据的到来。
16.5 下载验证
编译工程并生成比特流.bit文件。接下来我们下载程序，验证上位机与开发板通过RS232串口进行串口数据环回功能。
首先我们需要准备一个图 7.5.13.3所示的USB转串口线，将USB接口一端插入电脑上的USB口，另一端DB9接口与开发板上的COM2接口相连接，并将P1排针上的两个跳帽按照如下图所示的方式连接：

/ R' ~4 t- i' u* A  ^4 F6 @
2 l/ A3 p3 o* O" i, e+ X
图 7.5.13.1 串口连接和P1跳线帽连接
3 e1 Z$ u! M. A2 X" r/ _接下来分别连接JTAG接口和电源线，并打开电源开关。
3 o3 a7 n& P; L6 G6 y8 Z! L; W: g注意上位机第一次使用USB转串口线与FPGA开发板连接时，需要安装USB串口驱动。在开发板随附的资料中找到“6_软件资料/1_软件/CH340驱动(USB串口驱动)”的文件夹，双击打开文件夹中的“SETUP.EXE”进行安装，驱动安装界面如图 7.5.13.2所示。界面中提示INF文件为CH341SER.INF，我们不需要理会（CH341，CH340驱动是共用的），直接点安装即可。

. o# O$ M3 s2 I  w+ b6 S
4 _+ u; k4 S8 o2 {2 g
图 7.5.13.2 USB串口驱动驱动安装界面
开发板电源打开后，将本次实验的bit文件下载到开发板中。
. m4 Y: y4 C- S9 _接下来打开串口助手。串口助手是上位机中用于辅助串口调试的小工具，可以选择安装使用开发板随附资料中“6_软件资料/1_软件/串口调试助手”文件夹中提供的XCOM串口助手。在上位机中打开串口助手XCOM V2.0，如下图所示：
, a8 i, ~: J: s6 {) Y* ?3 F
* A: R/ @% `- h% _$ c1 `& ^. H

图 7.5.13.3 串口助手操作界面
在串口助手中选择与开发板相连接的CH340虚拟串口，具体的端口号（这里是COM4）需要根据实际情况选择，可以在计算机设备器中查看，如下图所示：
: e* D2 v2 {1 ^9 Y6 S+ _7 A) R
' X* R4 d. E' k

图 7.5.13.4 电脑的设备管理器窗口
7 ?& R' l0 b) _# v9 t7 g/ s8 K在串口助手中设置波特率为115200，数据位为8，停止位为1，无校验位，最后确认打开串口。
串口打开后，在发送文本框中输入数据“5A”并点击发送，可以看到串口助手中接收到数据“5A”，如图 7.5.13.3所示。串口助手接收到的数据与发送的数据一致，说明程序所实现的串口数据环回功能验证成功。
" z9 ], `, v* _: F8 @0 Z# x6 X$ ]————————————————
# n# O$ R2 _( }" h8 ~版权声明：正点原子

* c0 T; S% f: H: d+ [4 V$ S
5 c1 b5 r1 p8 V: U+ `