用verilog实现UART协议理解何为接口以及如何进行模块化设计

       UART是很简单的协议，也可以说是入门级的协议，它本身不值得我们花费多大的精力探讨，但是我们可以把它看作我们刚学C语言时候写下的”hello world”，刚学习单片机时候点亮的一个led灯，这样，它就有意义了，而且它的意义已经不再是实现一个功能了。我们要好好利用这个简单的协议去理解“协议”这个概念以及如何进行模块化设计，这对FPGA来说，是尤为重要的两个方面。

---

欢迎收看相关视频：UART协议讲解

主要内容为：

1•何为接口协议，认识UART协议2

2•如何设计模块，设计UART逻辑模块

3•怎样设计逻辑，实现UART逻辑设计

课程附带中art测试程序，支持不大于512字节的任意长度数据收发

---

接口协议

       为什么要单纯的去理解“协议”这个很虚的词呢？因为在我看来，对于刚接触协议或者FPGA这方面的朋友来说，知道“为什么这么做”比“知道怎么做”更重要。为什么这么说呢？

       记得我在上学时候，我把好多协议列个清单有，看着清单踌躇满志，准备像打怪升级那样一个一个的攻克，这样就能成为技术牛人，走向人生巅峰了，然后我就去看技术文档，去搞懂这是个什么协议，怎么工作的，硬件怎么连的，程序怎么写的，时序是什么样子的，搞了不久，我投降了。就拿我们经常会接触到协议来举例，uart、I2C、SPI，SDRAM、DDR、serdes、TCP/IP协议栈，其中TCP/IP协议占还包括UDP、TCP、RAP等待，还分了数据链路层等等，太多了太复杂了。我就被一堆一堆专业名词搞晕了，被看不懂的时序整糊涂了，被别人的程序逻辑整残了。那为什么会这样呢？心急，太想多学点多会点，太想学习更多的协议来提升自己，因此，只想知道这个怎么实现那个怎么做，把位置占的太低而不去考虑人家为什么这么设计，也就是忽略了为什么这么做。

      其实，协议是学不完的，哪怕今天你把所有的协议都学会了，明天还会有新的协议出现，但协议都是存在共性的，当我们知道为什么了这么做，并对此有深刻的体会，就会游刃有余各种协议，简单的协议，张口即来，复杂点的协议，看看就会，没有协议满足项目需求，那就造他个协议。

协议是什么呢？

        协议是人们根据器件的物理特性和使用场景想出来的让器件沟通的方法。器件不会说话，聪明的人类就设定一种方法让他们去沟通，通过交流去完成一些事情。所以说协议是人想出来的，哪怕再晦涩难懂那也是人想出来的，协议是源自于人、源自于生活的，我们是主人，是这些协议的设计者，我们要去俯视它，驾驭它甚至是玩弄它，我们要将抽象的东西回归到生活，站在一个更高的位置去做宏观的理解，然后带着这种理解和好奇心去看某个协议，看某篇文档，我想就会更有效率和动力。比如说，令人比较抓狂的专业名词，可以说就是将生活中的现象用在专业领域的另一种表述方式。

       什么是响应应答，就我说老师好，老师说同学们好，

       什么是通讯超时，就是我叫声美女，美女没理我。

       什么是三次握手，就是我看到小张了，说了句，“哟小张”，小张说嗯，我说，你真的是小张啊，小张来句，是的，我说，真的，小张说真的。这就是TCP/IP里面的三次握手也就是这个原理，握手好了就可以干其他事了，比如说，小张吃饭了没？这就是通讯内容

       可以说，一些专业名词不是可以通过生活中的现象去解释，而是它就是源自于我们的生活，那什么是协议呢？举几个例子，

        1、我走路上看到小张，我说句：“小张，吃饭了没？”，小张回复一句：“吃了”，这就是我和小张建立起了通讯机制，通讯链路是我们发声器官和空气，通讯协议就是汉语。

       2、我又走路上，看到一条小狗，蛮可爱的，我说句：“小狗，吃饭了没？”小狗回复一句：“汪汪”，吓得我拔腿就跑，就是我和小狗通讯建立失败，虽然通讯链路建立起来了，但通讯协议确实汉语和狗语，就好用uart协议去和TA24C02通讯，对不上啊。

       3、我又走路上，看到小赵我说句：“小赵”小赵回复一句：“嗯嗯“我说句：“吃了没”小赵回复一句：“吃了“，这就好比IIC协议，有起始信号，有应答信号。

       4、我又走路上，看到小李，我说句：“小李，吃饭了没？”小李回了句，刚从厕所出来”。这是啥，通讯建立了，但通讯内容校验有误，这就是为啥好多通讯要做CRC校验，循环校验。

        5、我走路上，看到一群美女，这把我激动的，说了句：“嗨，美女们，吃饭了没”？结果美女抬头一看这家伙怎么这么丑，没人回应我，心里想着“傻X”、“丑人多作怪”，这叫什么？多播或广播，在工程上也是用的比较多的一种方式。

所以说，通讯协议源自于生活，我们要有将抽象的东西回归到生活的心态，这样理解起来又容易又开心。

       回过头来我们再说，什么是接口协议，百度说接口协议就是需要进行信息交换的接口间需要遵从的通信方式和要求。通讯方式就是这信息是用什么传递的，拿什么运过去的，通信要求就是语法，是说用汉语还是英语还是什么的。也就是说我们要让两个器件进行沟通，首先要做什么呢？确定拿什么传，然后确定说什么话，最后可以说咱想说的了。当然这是简单的通讯建立，复杂的通讯原理一样，但建立过程很复杂。

UART协议

       现在就来看看UART协议。我是用什么传的呢？用USB转串口线连接上位机与FPGA板卡，FPGA板卡用MAX232做电平转换之后与FPGA芯片相连。

下面我们就看一下uart协议。

      UART串口通讯的工作原理是将传输数据的每个字符一位接一位地传输。UART是用两根线进行通信的，从一端看，一个用来收别人说的，一个是发自己说的，一根线它就有两种情况，要不是高电平，要不就是低电平，一根线咱们传数据呢？这就是事先说好的规定，也就是协议。大家可以想想，如果你来设计，咱们通过两根线来进行通讯，你会怎么设计呢？咱们先看看咱们的前辈是怎么设计的。他的格式就是“起始位（0）+八位数据+奇偶校验+停止位”，他的速度是由波特率来设定，空闲状态为高电平，这就是协议。下面咱们来理解一下。

什么是起始位，就是要说话了，咱们人说话得先出个声，叫个“嗨，小张”器件它不能发声，所以就要模拟一个与不出话时候不一样的情景，这就是起始位，因为空闲时候是高电平，所以当出现低电平时候表示可以说话了。

数据，就是和小张说话的内容，就是吃饭了没，比如说，我发个5就表示问小张吃饭了没，那一根线怎么发了，人家说了，每个字符一位接一位地传输，也就是把5转为为二进制00000101，接下来就好像敲电报似得发出去。发0吧数据线拉低了，发1把数据线拉高了，这样就发完了。

奇偶校验，什么是校验，就是判断对不对。比如，我问小张吃饭了没，同时做一个吃饭的动作，这小张听到我说吃饭了没，又看到我做吃饭的动作，就明白了我是在问他吃饭了没？如果我问他吃饭了没，又做个蹲坑的动作，小张就该迷茫了，这是在干啥呢，这时候校验不通过。对于uart就一根线，怎么校验，就数数你发的数里面有几个1,如果1的个数是计数就把

停止位，话说完了，数据线拉高，我不说了。

      为啥要设定波特率呢，例如我说，小张吃饭了没？如果说快了，他反应不过来，以为我问他去厕所了？说慢了，他还不耐烦。所以说，接收者和发送者速率要匹配。对于机器，你不告诉说多块，更迷茫了，所以就引出了波特率这个概念。但这只是我们一种粗浅的理解，其实波特率是一个很有历史的名词，它是为了纪念电报码的发明者法国人波特（Baudot）故单位为baud，波特率表示串口通信的速率，可以通俗的理解为一个设备在一秒钟内发送（或接收）了多少码元符号。

它是对符号传输速率的一种度量，1波特即指每秒传输1个码元。在数字通信中常常用时间间隔相同的符号来表示一个二进制数字，这样的时间间隔内的信号称为(二进制）码元。大家有兴趣可以看百度百科的介绍https://baike.baidu.com/item/%E6%B3%A2%E7%89%B9%E7%8E%87/2153185?fr=aladdin

如果波特率为9600，也就是每秒发送9600个数据（这里的数据包括起始、停止、校验位等，这也就是和比特率的区别，比特率说的是有效数据），这样的话发送一个数据的时间就是1÷9600=0.0001041667s=104166ns，我们晶振是50MHZ，时钟周期是20ns，所以计数个数为104166÷20=5208。所以，当我们在计数5208过程中要完成一位数据的传输，但为了保险起见，我们在这个数的中间进行传输，也就是2604时一位发送数据。

模块化设计，模块化设计对FPGA工程师来说是非常重要的，合理的模块划分和封装不仅会使代码更友好，而且也非常利于维护，以下是我对模块划分的想法。

       就uart协议的模块划分，我是这样做的

把这个封装一下，就是这样的

具体程序如下：

1、波特率设置模块

1. module bps_set
   
2. #(
   
3.     parameter BPS_CNT = 16'd5208
   
4. )
   
5. (
   
6.     input   wire    sys_clk,
   
7.     input   wire    sys_rst_n,
   
8.         
   
9.     output  wire    rx_bps_vld,
   
10.     input   wire    rx_bps_en,
    
11.         
    
12.     output  wire    tx_bps_vld,
    
13.     input   wire    tx_bps_en
    
14. );
    
15. 
    
16.     localparam  BPS_HALF_CNT =( BPS_CNT>>1) - 1'b1;
    
17. 
    
18.     reg [15:0] rx_pbs_cnt;
    
19.     reg [15:0] tx_pbs_cnt;
    
20. 
    
21. //------------------------- rx cnt------------------------        
    
22.     always @ (posedge sys_clk or negedge sys_rst_n)
    
23.         if(!sys_rst_n)
    
24.             rx_pbs_cnt <= 16'b0;
    
25.         else if(rx_pbs_cnt == BPS_CNT - 1'b1)
    
26.             rx_pbs_cnt <= 16'b0;
    
27.         else if(rx_bps_en)
    
28.             rx_pbs_cnt <= rx_pbs_cnt + 1'b1;
    
29.         else
    
30.             rx_pbs_cnt <= 16'b0;
    
31.             
    
32. //------------------------- tx cnt------------------------               
    
33.     always @ (posedge sys_clk or negedge sys_rst_n)
    
34.         if(!sys_rst_n)
    
35.             begin
    
36.             tx_pbs_cnt <= 16'b0;
    
37.             end
    
38.         else if(tx_pbs_cnt == BPS_CNT)
    
39.             tx_pbs_cnt <= 16'b0;
    
40.         else if(tx_bps_en)
    
41.             tx_pbs_cnt <= tx_pbs_cnt + 1'b1;
    
42.         else
    
43.             tx_pbs_cnt <= 16'b0;
    
44.             
    
45.     assign rx_bps_vld = (rx_pbs_cnt == BPS_HALF_CNT) ? 1'b1 : 1'b0;
    
46.     assign tx_bps_vld = (tx_pbs_cnt == (BPS_CNT -1)) ? 1'b1 : 1'b0;
    
47.    
    
48. endmodule
    
49.         

复制代码

2、数据接收模块

1. module rx_data
   
2. (
   
3.     input wire sys_clk,
   
4.     input wire sys_rst_n,
   
5.    
   
6.     input wire rx_pin,
   
7.    
   
8.     input wire rx_bps_vld,
   
9.     output reg rx_bps_en,
   
10.    
    
11.     output reg rx_data_vld,
    
12.     output reg [7:0] rx_data
    
13. 
    
14. );
    
15. 
    
16. //---------------- parm ------------------------
    
17.     localparam IDLE     = 4'h0;
    
18.     localparam START    = 4'h1;
    
19.     localparam DATA     = 4'h2;
    
20.     localparam CHECK    = 4'h4;
    
21.     localparam STOP            = 4'h8;
    
22.    
    
23.     reg [3:0]   cs;
    
24.     reg [3:0]   ns;        
    
25. //----------------------------------------        
    
26.     reg         rx_pin_dly;
    
27.     reg         rx_pin_dly1;
    
28.     reg [3:0]   data_cnt;
    
29.     reg [7:0]   rxdata;
    
30.    
    
31. //----------------------------------------
    
32.     always @ (posedge sys_clk or negedge sys_rst_n)
    
33.         if(!sys_rst_n)
    
34.             cs <= IDLE;
    
35.         else
    
36.             cs <= ns;
    
37.         
    
38.         
    
39.     always @ (*)
    
40.         begin
    
41.         ns = IDLE;
    
42.         case(cs)
    
43.     //----------------IDLE wait data---------------------
    
44.             IDLE:
    
45.                 if(rx_pin_dly1 & !rx_pin_dly)
    
46.                     ns = START;
    
47.                 else
    
48.                     ns = IDLE;
    
49.     //---------------- start sig ------------------------
    
50.             START:
    
51.                 if(rx_bps_vld && !rx_pin_dly1)
    
52.                     ns = DATA;
    
53.                 else if(rx_bps_vld && rx_pin_dly1)
    
54.                     ns = IDLE;
    
55.                 else
    
56.                     ns = START;
    
57.     //-----------------data 8bit-----------------------
    
58.             DATA:
    
59.                 if(data_cnt == 4'd7)
    
60.                     ns = STOP;
    
61.                 else
    
62.                     ns = DATA;
    
63.     //------------------ no use ----------------------
    
64.             CHECK:
    
65.                 if(rx_bps_vld)
    
66.                     ns = STOP;
    
67.                 else
    
68.                     ns = CHECK;
    
69.     //----------------------------------------
    
70.             STOP:
    
71.                 if(rx_bps_vld)
    
72.                     ns = IDLE;
    
73.                 else
    
74.                     ns = STOP;
    
75.                     
    
76.             default:ns = IDLE;
    
77.         endcase
    
78.         end
    
79.    
    
80. //------------------------ buffer ----------------------------------        
    
81.    
    
82.     always @ (posedge sys_clk or negedge sys_rst_n)
    
83.         if(!sys_rst_n) begin
    
84.             rx_pin_dly         <= 1'b1;
    
85.             rx_pin_dly1        <= 1'b1;
    
86.         end else  begin
    
87.             rx_pin_dly         <= rx_pin;        
    
88.             rx_pin_dly1        <= rx_pin_dly;
    
89.         end
    
90.    
    
91. //----------------------------------------------------------        
    
92.     always @ (posedge sys_clk or negedge sys_rst_n)
    
93.         if(!sys_rst_n)
    
94.             rx_bps_en <= 1'b0;
    
95.         else if((ns == START)&(cs == IDLE))
    
96.             rx_bps_en <= 1'b1;
    
97.         else if((ns == IDLE)&(cs == STOP))
    
98.             rx_bps_en <= 1'b0;
    
99.         else
    
100.             rx_bps_en <= rx_bps_en;
     
101.    
     
102. //----------------------------------------------------------        
     
103.     always @ (posedge sys_clk or negedge sys_rst_n)
     
104.         if(!sys_rst_n)
     
105.             data_cnt <= 4'd0;
     
106.         else if(cs == IDLE)
     
107.             data_cnt <= 4'd0;
     
108.         else if((cs == DATA)&&rx_bps_vld)
     
109.             data_cnt <= data_cnt + 1'b1;
     
110.         else
     
111.             data_cnt <= data_cnt;
     
112.             
     
113. //----------------------------------------------------------                        
     
114.     always @ (posedge sys_clk or negedge sys_rst_n)
     
115.         if(!sys_rst_n)
     
116.             rxdata <= 8'd0;
     
117.         else if((cs == DATA) && rx_bps_vld) //dly
     
118.             rxdata[data_cnt] <= rx_pin_dly;
     
119.         else if(cs == IDLE)
     
120.             rxdata <= 8'd0;
     
121.         else
     
122.             rxdata <= rxdata;               
     
123.             
     
124. //----------------------------------------------------------        
     
125.     always @ (posedge sys_clk or negedge sys_rst_n)
     
126.         if(!sys_rst_n)         begin
     
127.             rx_data_vld <= 1'b0;
     
128.             rx_data                <= 8'd0;
     
129.         end else if((cs == STOP) && rx_bps_vld ) begin
     
130.             rx_data_vld <= 1'b1;
     
131.             rx_data                <= rxdata;
     
132.         end else begin
     
133.             rx_data_vld <= 1'b0;
     
134.             rx_data                <= rx_data;
     
135.         end
     
136.             
     
137. endmodule
     
138. 
     
139. 
     
140. 
     
141. 
     
142. 
     

复制代码

3、发送模块

1. module tx_data
   
2. (
   
3.     input   wire            sys_clk,
   
4.     input   wire            sys_rst_n,
   
5.    
   
6.     output  wire            tx_pin,
   
7.     input   wire            tx_data_vld,
   
8.     input   wire    [7:0]   tx_data,
   
9.     input   wire            tx_bps_vld,
   
10.     output  reg             tx_bps_en,
    
11.     output  wire            tx_over
    
12.    
    
13. );
    
14. 
    
15. //-------------- localparam ----------------
    
16. 
    
17.     localparam IDLE     = 4'h0;
    
18.     localparam START    = 4'h1;
    
19.     localparam DATA     = 4'h2;
    
20.     localparam CHECK    = 4'h4;
    
21.     localparam STOP     = 4'h8;
    
22.    
    
23.     reg     [3 :0]      cs;
    
24.     reg     [3 :0]      ns;
    
25.    
    
26.     reg                 tx_pin_buf;
    
27.     reg                 empty_dly1;
    
28.    
    
29.     wire    [7 :0]      rd_data;
    
30.     reg                 rd_en;
    
31.     wire                empty;
    
32.     reg     [3 :0]      tx_cnt;
    
33.     reg                [15:0]                stop_delay_cnt;
    
34.    
    
35.     tx_fifo tx_fifo//512
    
36.     (
    
37.         .clock      ( sys_clk       ),
    
38.         .wrreq      ( tx_data_vld   ),
    
39.         .data       ( tx_data       ),
    
40.    
    
41.         .rdreq      ( rd_en         ),
    
42.         .q          ( rd_data       ),
    
43.         .empty      ( empty         )
    
44.     );
    
45.    
    
46.     always @ (posedge sys_clk or negedge sys_rst_n)
    
47.         if(!sys_rst_n) begin
    
48.             empty_dly1 <= 1'b0;
    
49.         end else begin
    
50.             empty_dly1 <= empty;
    
51.         end        
    
52.    
    
53.     always @ (posedge sys_clk or negedge sys_rst_n)
    
54.         if(!sys_rst_n) begin
    
55.             tx_bps_en <= 1'b0;
    
56.         end else if(!empty && empty_dly1) begin//negedge
    
57.             tx_bps_en <= 1'b1;
    
58.         end else if(empty && (cs == STOP) && (ns == IDLE) )        begin
    
59.             tx_bps_en <= 1'b0;
    
60.         end else begin
    
61.             tx_bps_en <= tx_bps_en;        
    
62.         end
    
63. 
    
64. //--------------------------------------------------------               
    
65.     always @ (posedge sys_clk or negedge sys_rst_n)
    
66.         if(!sys_rst_n)
    
67.             rd_en <= 1'b0;
    
68.         else if((cs == IDLE) &&(ns == START))
    
69.             rd_en <= 1'b1;
    
70.         else
    
71.             rd_en <= 1'b0;
    
72.             
    
73. //***********************************************************                        
    
74.     always @ (posedge sys_clk or negedge sys_rst_n)
    
75.         if(!sys_rst_n)
    
76.             cs <= IDLE;
    
77.         else
    
78.             cs <= ns;
    
79. 
    
80.     always @ (*)
    
81.         begin
    
82.         ns = IDLE;
    
83.         case(cs)
    
84.         IDLE:
    
85.             if(tx_bps_en )
    
86.                 ns = START;
    
87.             else
    
88.                 ns = IDLE;
    
89.         
    
90.         START:
    
91.             if(tx_bps_vld )
    
92.                 ns = DATA;
    
93.             else
    
94.                 ns = START;
    
95.    
    
96.         DATA:
    
97.             if((tx_cnt == 7) && tx_bps_vld)
    
98.                 ns = CHECK;
    
99.             else
    
100.                 ns = DATA;
     
101.             
     
102.         CHECK:
     
103.             if(tx_bps_vld)
     
104.                 ns = STOP;
     
105.             else
     
106.                 ns = CHECK;
     
107.    
     
108.         STOP:
     
109.             if(tx_bps_vld)
     
110.                 ns = IDLE;
     
111.             else
     
112.                 ns = STOP;
     
113.         
     
114.         default:ns = IDLE;
     
115.         endcase
     
116.         end
     
117.                         
     
118. //--------------------------------------------------------        
     
119.     always @ (posedge sys_clk or negedge sys_rst_n)
     
120.         if(!sys_rst_n)
     
121.             tx_cnt <= 4'd0;
     
122.         else if((cs == DATA) && tx_bps_vld)        
     
123.             tx_cnt <= tx_cnt + 4'd1;
     
124.         else if(cs == IDLE)
     
125.             tx_cnt <= 4'd0;
     
126.         else
     
127.             tx_cnt <= tx_cnt;
     
128. //--------------------------------------------------------                                       
     
129.     always @ (posedge sys_clk or negedge sys_rst_n)
     
130.         if(!sys_rst_n)        
     
131.             tx_pin_buf <= 1'b1;
     
132.         else if(cs == START)
     
133.             tx_pin_buf <= 1'b0;
     
134.         else if(cs == DATA)
     
135.             tx_pin_buf <= rd_data[tx_cnt];
     
136.         else if(cs == CHECK)
     
137.             tx_pin_buf <= 1'b1;
     
138.         else if(cs == STOP)
     
139.             tx_pin_buf <= 1'b1;
     
140.         else
     
141.             tx_pin_buf <= 1'b1;        
     
142.                           
     
143.     assign      tx_pin = tx_pin_buf;
     
144.     assign      tx_over = (empty && (cs == STOP) && (ns == IDLE) ) ? 1'b1 : 1'b0;
     
145.                         
     
146. endmodule
     
147.    

复制代码

很棒，最近也是在做FPGA串口通信的实验。前面解释的很到位，程序没什么注释看起来好累