AG1280串口通信

因为上次做的板子是将FPGA和一块MCU芯片集成在一块的，他们之间就需要通信，当然最容易实现的就是UART串口通信；

下面的代码是一个Demo代码，实现的功能是，RX接收到什么，TX就发送相同的数据；

FPGA芯片 AG1280Q48
时钟频率 48MHZ
波特率 921600
RX引脚 PIN_16
TX引脚 PIN_14
LED引脚 PIN_48
时钟输入引脚 PIN_15
复位引脚 PIN_17

具体代码如下：

顶层模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
module connect_mcu (input clk,
                    input rst_n,
                    input wire uart_rx,
                    output wire uart_tx,
                    output wire led);
    
    wire clk_pll_o; //PLL时钟
    
    inpll pll_inst (
    .clkin(clk),		// PLL.clkin MUST connect to PIN_XX_GB
    .clkfb(clk_pll_o),
    .pllen(1'b1),
    .resetn(rst_n),
    .clkout0en(1'b1),
    .clkout1en(1'b0),
    .clkout2en(1'b0),
    .clkout3en(1'b0),
    .clkout0(clk_pll_o),
    .clkout1(),
    .clkout2(),
    .clkout3(),
    .lock()
    );
    
    parameter  SYSTERM_CLK = 26'd48_000_000;               //系统时钟频率
    parameter  UART_BPS    = 20'd921600;                   //串口波特率
    
    wire       flag;
    wire [7:0] data;
    // assign led = data[0];
    
    uart_receive
    #(
    .SYSTERM_CLK   (SYSTERM_CLK),
    .UART_BPS      (UART_BPS)
    )
    
    u_uart_receive(
    .clk          (clk_pll_o),
    .rst_n        (rst_n),
    .uart_rx      (uart_rx),
    .receive_done (flag),
    .uart_data    (data)
    );
    
    uart_send
    #(
    .SYSTERM_CLK   (SYSTERM_CLK),
    .UART_BPS      (UART_BPS)
    )
    
    u_uart_send(
    .clk          (clk_pll_o),
    .rst_n        (rst_n),
    .uart_in_data (data),
    .uart_in_flag (flag),
    .uart_tx      (uart_tx)
    );
    
    
    reg [1:0] led_counter;
    assign led = led_counter[0];
    
    // parameter SEC_TIME = 32'd48_000_000;//48M
    reg	[31:0] cnt;
    
    always @ (posedge clk_pll_o or negedge rst_n)begin
        if (rst_n == 0)
            cnt <= 0;
        else if (cnt<32'd12_000_000)
            cnt <= cnt+1;
        else
            cnt <= 0;
    end
    
    always @ (posedge clk_pll_o or negedge rst_n)begin
        if (rst_n == 0)
            led_counter <= 0;
        else if (cnt<32'd6_000_000)
        begin
            led_counter <= 1;
        end
        else
        begin
            led_counter <= 0;
        end
    end
    
endmodule

接收模块

接收模块的主要设计是将起始位下降沿的检测作为接收系统的开始信号，通过起始信号和bit位的计数信号相结合就可以得到一个贯穿整体运行过程的使能信号，通过对使能信号的判断就可以实现对系统的控制。

另一个关键问题是电平采集的时间，应该 在一个bit的中间位置进行采集，这样可以有效避免采集电平不稳定的问题。

接收模块的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
module uart_receive (input clk,
                     input rst_n,
                     input uart_rx,
                     output reg receive_done,
                     output reg [7:0] uart_data);
    parameter  SYSTERM_CLK   = 48_000_000;               //系统时钟频率
    parameter  UART_BPS      = 921600;                     //串口波特率
    localparam BPS_COUNT_MAX = SYSTERM_CLK/UART_BPS;     //为得到指定波特率
    //需要对系统时钟计数BPS_COUNT次
    reg      [7:0]       reg_data;//接受数据缓存
    reg      [3:0]       bit_count;//接收数据时用于计数接收到了多少位
    reg      [12:0]      bps_count;//用于按照时钟计算一个字节的时间
    reg                  start_bit;//检测到起始位的下降沿之后触发一个时钟的高电平
    reg                  reg1     ;
    reg                  reg2     ;
    reg                  reg3     ;
    reg                  bit_flag ;//在一个电平的中间位置产生高电平标志
    reg                  work_en  ;//在本标志位高电平时，接受工作开始，在低电平时工作结束
    reg                  rx_flag  ;//在数据缓存器存满了之后产生一个高电平
    
    //插入两级寄存器进行数据同步，用来消除亚稳态
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            reg1 <= 1'b1;//因为UART的空闲状态是高电平，所以复位时电平要设置为高电平
        end
        else        begin
            reg1 <= uart_rx;
        end
    end
    //插入两级寄存器进行数据同步，用来消除亚稳态
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            reg2 <= 1'b1;//因为UART的空闲状态是高电平，所以复位时电平要设置为高电平
        end
        else        begin
            reg2 <= reg1;
        end
    end
    
    //插入两级寄存器进行数据同步，用来消除亚稳态
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            reg3 <= 1'b1;//因为UART的空闲状态是高电平，所以复位时电平要设置为高电平
        end
        else        begin
            reg3 <= reg2;
        end
    end
    //start_bit用来检测起始位的下降沿
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            start_bit <= 1'b0;
        end
        else if ((reg3)&&(!reg2)) begin
            start_bit <= 1'b1;
        end
        else
            start_bit <= 1'b0;
    end
    //work_en,在本标志位高电平时，接受工作开始，在低电平时工作结束
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            work_en <= 1'b0;
        end
        else if (start_bit) begin
            work_en <= 1'b1;
        end
            else if ((bit_count == 4'd8) && (bit_flag == 1'b1)) begin
            work_en <= 1'b0;
            end
        else
            work_en <= work_en;
    end
    //bps_count用来计数计算波特率
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            bps_count <= 13'b0;
        end
        else if ((bps_count == BPS_COUNT_MAX -1) || (work_en == 0)) begin
            bps_count <= 13'b0;//只有在工作使能的状态下才会计数
            end
        else if (work_en == 1) begin
            bps_count <= bps_count + 1'b1;
        end
        else
            bps_count <= bps_count;
    end
    //bit_flag,在一个字节的中点输出一个时钟的高电平
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            bit_flag <= 1'b0;
        end
        else if (bps_count == BPS_COUNT_MAX/2-1) begin
            bit_flag <= 1'b1;
        end
        else
            bit_flag <= 1'b0;
    end
    //bit_count,用于计数当前接收到了第几bit
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            bit_count <= 4'b0;
        end
        else if ((bit_count == 4'd8) && (bit_flag == 1'b1)) begin
            bit_count <= 4'b0;
        end
            else if (bit_flag == 1'b1) begin
            bit_count <= bit_count + 1'b1;
            end
        else
            bit_count <= bit_count;
    end
    //reg_data表示接收数据的缓存
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            reg_data <= 8'b0;
        end
        else if ((bit_flag == 1) && (work_en == 1) && (bit_count <= 4'd8) && (bit_count >= 4'd1)) begin
            reg_data <= {reg3,reg_data[7:1]};
        end
        else
            reg_data <= reg_data;
    end
    //rx_flag在接收缓存满了之后输出一个时钟的高电平
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            rx_flag <= 1'b0;
        end
        else if ((bit_count == 4'd8) && (bit_flag == 1'b1)) begin
            rx_flag <= 1'b1;
        end
        else
            rx_flag <= 1'b0;
    end
    //uart_data将数据缓存器中的数据导出
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            uart_data <= 8'b0;
        end
        else if (rx_flag == 1'b1) begin
            uart_data <= reg_data;
        end
        else
            uart_data <= uart_data;
    end
    //receive_done导出接收完成的信号
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            receive_done <= 1'b0;
        end
        else if (rx_flag == 1'b1) begin
            receive_done <= 1'b1;
        end
        else
            receive_done <= 1'b0;
    end

endmodule //uart_receive

发送模块

UART的发送模块的实现过程比接收过程稍简单，因为发送模块无需考虑采集电平的位置，只需要在接收到发送使能之后，通过计算每一个bit的时间，按照顺序将数据发送出去即可。

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
module uart_send (input wire clk,
                  input wire rst_n,
                  input wire [7:0] uart_in_data,
                  input wire uart_in_flag,
                  output reg uart_tx);
    parameter  SYSTERM_CLK   = 48_000_000;               //系统时钟频率
    parameter  UART_BPS      = 921600;                     //串口波特率
    localparam BPS_COUNT_MAX = SYSTERM_CLK/UART_BPS;     //为得到指定波特率
    //需要对系统时钟计数BPS_COUNT次
    reg      [12:0]      bps_count;//用于按照时钟计算一个字节的时间
    reg      [3:0]       bit_count;//接收数据时用于计数接收到了多少位
    reg                  bit_flag ;//在一个电平的中间位置产生高电平标志
    reg                  work_en  ;//在本标志位高电平时，接受工作开始，在低电平时工作结束
    
    //bps_count波特率计数器
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            bps_count <= 13'b0;
        end
        else if ((bps_count == BPS_COUNT_MAX - 1'b1) || (work_en == 1'b0)) begin
            bps_count <= 13'b0;
            end
        else if (work_en == 1'b1) begin
            bps_count <= bps_count + 1'b1;
        end
        else
            bps_count <= bps_count;
    end
    //work_en发送工作使能
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            work_en <= 1'b0;
        end
        else if ((bit_count == 4'd9) && (bit_flag == 1'b1)) begin
            work_en <= 1'b0;
        end
            else if (uart_in_flag == 1'b1) begin
            work_en <= 1'b1;
            end
        else
            work_en <= work_en;
    end
    //bit_flag每一个bit的信号
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            bit_flag <= 1'b0;
        end
        else if (bps_count == 13'b1) begin
            bit_flag <= 1'b1;
        end
        else
            bit_flag <= 1'b0;
    end
    //bit_count字节计数
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            bit_count <= 4'b0;
        end
        else if ((bit_flag == 1'b1) && (work_en == 1'b1)) begin
            bit_count <= bit_count + 1'b1;
        end
            else if ((bit_count == 4'd9) && (bit_flag == 1'b1)) begin
            bit_count <= 4'b0;
            end
        else
            bit_count <= bit_count;
    end
    //uart_tx
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            uart_tx <= 1'b1;//串口传输，空闲时为高电平
        end
        else if (bit_flag == 1'b1) begin
            case (bit_count)
                0:  uart_tx     <= 1'b0           ;
                1:  uart_tx     <= uart_in_data[0];
                2:  uart_tx     <= uart_in_data[1];
                3:  uart_tx     <= uart_in_data[2];
                4:  uart_tx     <= uart_in_data[3];
                5:  uart_tx     <= uart_in_data[4];
                6:  uart_tx     <= uart_in_data[5];
                7:  uart_tx     <= uart_in_data[6];
                8:  uart_tx     <= uart_in_data[7];
                9:  uart_tx     <= 1'b1           ;
                default uart_tx <= 1'b1       ;
            endcase
        end
            end
    
endmodule //uart_send

引脚配置

1
2
3
4
5
6
7
8
set_location_assignment PIN_15 -to clk 
set_location_assignment PIN_17 -to rst_n 
set_location_assignment PIN_48 -to led 

set_location_assignment PIN_14 -to uart_tx 
set_location_assignment PIN_16 -to uart_rx 

set_global_assignment -name RESERVE_ALL_UNUSED_PINS "AS INPUT TRI-STATED"

运行截图

f1992c7fce5ccbde038bca329048345
赏

谢谢你请我喝可乐

支付宝
微信

扫一扫，分享到微信

微信分享二维码
本站总访问量次 |

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一枚立志成为嵌入式开发攻城狮的大学生 <br>Tel:15203783930 <br>QQ:2253770787 <br>微信:15110879029