0


FPGA入门 —— FPGA UART 串口通信

FPGA入门 —— FPGA UART 串口通信

串口简介

UART 通用异步收发传输器( Universal Asynchronous Receiver/Transmitter) ,通常称作 UART。 UART 是一种通用的数据通信协议,也是异步串行通信口(串口)的总称,它在发送数据时将并行数据转换成串行数据来传输,在接收数据时将接收到的串行数据转换成并行数据。 它包括了ch340、 RS232、 RS499、 RS423、 RS422 和 RS485 等接口标准规范和总线标准规范

串口作为常用的三大低速总线(UART、 SPI、 IIC)之一,在设计众多通信接口和调试时占有重要地位。但 UART 和 SPI、 IIC 不同的是,它是异步通信接口,异步通信中的接收方并不知道数据什么时候会到达,所以双方收发端都要有各自的时钟,在数据传输过程中是不需要时钟的,发送方发送的时间间隔可以不均匀,接受方是在数据的起始位和停止位的帮助下实现信息同步的。而 SPI、 IIC 是同步通信接口,同步通信中双方使用频率一致的时钟,在数据传输过程中时钟伴随着数据一起传输,发送方和接收方使用的时钟都是由主机提供的

UART 通信只有两根信号线,一根是发送数据端口线叫 tx(Transmitter),一根是接收数据端口线叫 rx(Receiver),对于 PC 来说它的 tx 要和对于 FPGA 来说的 rx 连接,同样 PC 的 rx 要和 FPGA 的 tx 连接,如果是两个 tx 或者两个 rx 连接那数据就不能正常被发送出去和接收到,所以不要弄混,记住 rx 和 tx 都是相对自身主体来讲的。UART 可以实现全双工,即可以同时进行发送数据和接收数据

串口回环模块如下图所示,使用电脑上位机串口模块完成对 FPGA 串口模块的环回实验

串口时序

下面我们来看一下 RS232 协议:

  1. RS232 是 UART 的一种,没有时钟线,只有两根数据线,分别是 rx 和 tx,这两根线都是 1bit 位宽的。其中 rx 是接收数据的线, tx 是发送数据的线
  2. rx 位宽为 1bit, PC 机通过串口调试助手往 FPGA 发 8bit 数据时, FPGA 通过串口线rx 一位一位地接收,从最低位到最高位依次接收,最后在 FPGA 里面位拼接成 8 比特数据,也就是我们常说的串转并
  3. tx 位宽为 1bit, FPGA 通过串口往 PC 机发 8bit 数据时, FPGA 把 8bit 数据通过 tx线一位一位的传给 PC 机,从最低位到最高位依次发送,最后上位机通过串口助手按照RS232 协议把这一位一位的数据位拼接成 8bit 数据,并行数据转换成串行数据进行发送
  4. 串口数据的发送与接收是基于帧结构的,即一帧一帧的发送与接收数据。每一帧除了中间包含 8bit 有效数据外,还在每一帧的开头都必须有一个起始位,且固定为 0;在每一帧的结束时也必须有一个停止位,且固定为 1,即最基本的帧结构(不包括校验等)有10bit。在不发送或者不接收数据的情况下, rx 和 tx 处于空闲状态,此时 rx 和 tx 线都保持高电平,如果有数据帧传输时,首先会有一个起始位,然后是 8bit 的数据位,接着有 1bit的停止位,然后 rx 和 tx 继续进入空闲状态,然后等待下一次的数据传输

rs232时序图入下图所示:

  1. 波特率:在信息传输通道中,携带数据信息的信号单元叫码元(因为串口是 1bit 进行传输的,所以其码元就是代表一个二进制数), 每秒钟通过信号传输的码元数称为码元的传输速率,简称波特率,常用符号“Baud”表示,其单位为“波特每秒(Bps)”。串口常见的波特率有 4800、9600、 115200 等
  2. 比特率:每秒钟通信信道传输的信息量称为位传输速率,简称比特率,其单位为“每秒比特数(bps)”。比特率可由波特率计算得出,公式为:比特率=波特率 * 单个调制状态对应的二进制位数。如果使用的是 115200 的波特率,其串口的比特率为: 115200Bps *1bit= 115200bps
  3. 由计算得串口发送或者接收 1bit 数据的时间为一个波特,即 1/9600 秒,如果用 50MHz(周期为 20ns)的系统时钟来计数,需要计数的个数为 cnt = (1s * 10^9)ns /115200bit)ns / 20ns ≈434 个系统时钟周期,即每个 bit 数据之间的间隔要在 50MHz 的时钟频率下计数 434 次

串口模块设计

我们先绘制一下串口回环的整个模块图:

由整个回环模块图,我们可以看出在整个回环实验中,我们需要再设计两个模块,一个接收模块和一个发送模块。

接收模块

先看一下接收模块的波形图:

输入信号为系统时钟、复位信号以及接收信号;为了消除跨时钟域所带来的的亚稳态现象,需要对 rx 信号进行打 3 拍操作,跨时钟域处理推荐是 3 拍,当然有些人觉得 2 拍足矣,只要验证没问题,这个你随意。

进行完打拍操作后,需要取第三拍的下降沿操作,也就是 ~rx_reg2 & rx_reg3 ,至于为何这样,可以参考边沿检测部分。

得到 start_flag 信号之后,就可以进行一个 rx 的接收了,本次接收模块使用的波特率为 115200,系统时钟为 50M,所以波特率为 50_000_000/115200=434,当然这里波特率也可以根据需要进行修改

为了每位数据的接收的稳定,所以可以数据的标志信号可以在波特率信号的中间位置进行拉高。然后将每 bit 的数据都拼接到我们接收数据的最高位,以此类推,接收到的第8位数据,就拼接在了 rx_data 的最高位,最先接收的数据就存储在了 rx_data 的最低位

接收完8位数据之后,我们的接收标志信号拉高,表示已经完成一次8位数据的接收。在接收完成标志位拉高后,将我们寄存的串转并的数据赋值 po_data,同样 po_flag 拉高一个周期

根据波形图与文字分析,可以编写代码如下:

UART_recv.v

module UART_recv 
#(
    parameter  CLK         =   26'd50000000    ,    // 时钟频率
    parameter  BAUD        =   17'd115200           // 波特率
)
(
    input   wire            clk         ,
    input   wire            rstn        ,
    input   wire            UART_rx     ,

    output  reg             flag_out    ,   // 数据接收完成标志位,既发送开始标志位
    output  reg    [7 : 0]  data_out        // 接收的数据
);

    localparam Baud_Clk     =   CLK/BAUD       ;    // 传输每个 Baud 需要的时钟数

    reg             rx_en       ;   // 接收使能
    reg             start_flag  ;   // 开始接收标志
    reg             flag_rx     ;   // 接收标志位,半个时钟周期为 1 ,用于判断数据已经全部接收完成
    reg             flag_bit    ;   // 比特标志位,采用下降沿发送
    reg             rx_reg1     ;   // 接收寄存器1,同步打拍(打一拍延时一个时钟周期)
    reg             rx_reg2     ;   // 接收寄存器2
    reg             rx_reg3     ;   // 接收寄存器3,取第三拍下降沿进行边缘检测
    reg [8 : 0]     cnt_baud    ;   // 波特率计数器
    reg [7 : 0]     data_rx     ;   // 接收数据寄存器
    reg [3 : 0]     cnt_bit     ;   // 比特计数器

    // 打三拍
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            rx_reg1 <= 1'b1;
            rx_reg2 <= 1'b1; 
            rx_reg3 <= 1'b1;
        end
        else begin
            rx_reg1 <= UART_rx;
            rx_reg2 <= rx_reg1;
            rx_reg3 <= rx_reg2;
        end
    end

    // 检测第三拍下降沿,用作数据接收信号
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            start_flag <= 1'b0;
        end
        // 判断第三拍下降沿
        else if(rx_reg3 && ~rx_reg2) begin
            start_flag <= 1'b1;
        end
        else begin
            start_flag <= 1'b0;
        end
    end

    // 接收使能
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            rx_en <= 1'b0;
        end
        // 下降沿接收
        else if(start_flag == 1'b1) begin
            rx_en <= 1'b1;
        end
        // 接收完成,输入只需要判断到数据位最后一位,输出则需要判断完整输出
        else if(cnt_bit == 4'd8 && flag_bit == 1'b1) begin
            rx_en <= 1'b0;
        end
    end

     // 波特计数器
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            cnt_baud <= 9'd0;
        end
        // 传输完成所有波特或者使能失效,表示接收结束
        else if(cnt_baud == Baud_Clk - 1'b1 || rx_en == 1'b0) begin
            cnt_baud <= 9'd0;
        end
        // 只有输入使能才能计数
        else if(rx_en == 1'b1) begin
            cnt_baud <= cnt_baud + 9'd1;
        end
    end

    // 比特标志位
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            flag_bit <= 1'b0;
        end
        // 半个周期反转一次,输入一个bit需要两个时钟周期,输出需要三个
        else if(cnt_baud == Baud_Clk/2 - 1'b1) begin
            flag_bit <= 1'b1;
        end
        else begin
            flag_bit <= 1'b0;
        end
    end

    // 比特计数器
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            cnt_bit <= 4'd0;
        end
        // 输入判断完成
        else if(cnt_bit == 4'd8 && flag_bit == 1'b1) begin
            cnt_bit <= 4'd0;
        end
        // 前面判断了输入使能失效,无法进行波特计数
        else if(flag_bit == 1'b1) begin
            cnt_bit <= cnt_bit + 4'd1;
        end
    end

    // 接收数据
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            data_rx <= 8'd0;
        end
        // 只要开始接收,就开始存储数据,1-8为数据位,解析输入数据,从最低位向最高位输入
        else if(cnt_bit >= 4'd1 && cnt_bit <= 4'd8 && flag_bit == 1'b1) begin
            data_rx <= {rx_reg3,data_rx[7:1]};
        end
    end

    // 接收标志位
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            flag_rx <= 1'b0;
        end
        // 数据接收完成,输出半个时钟周期的 1 用于数据转存,将收到的数据再次发送出去
        else if(cnt_bit == 4'd8 && flag_bit == 1'b1) begin
            flag_rx <= 1'b1;
        end
        else begin
            flag_rx <= 1'b0;
        end
    end

    // 接收的串转并数据
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            data_out <= 8'd0;
        end
        // 判断数据已经全部接收完成
        else if(flag_rx == 1'b1) begin
            data_out <= data_rx;
        end
    end

    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            flag_out <= 1'b0;
        end
        else begin
            flag_out <= flag_rx;
        end
    end

endmodule //UART_recv

编写接收模块仿真代码:

tb_uart_rx.v:

`timescale 1ns / 1ns
 
module tb_uart_rx();
 
reg               sys_clk     ;
reg               sys_rst_n   ;
reg               rx          ;
                              
wire      [7:0]   po_data     ;
wire              po_flag     ;
 
 
initial begin
    sys_clk = 1'b1;
    sys_rst_n <= 1'b0;
    #201
    sys_rst_n <= 1'b1;
end
 
always #10 sys_clk = ~sys_clk;
 
//模拟发送8次数据,分别为0~7
initial begin
        #200
        rx_bit(8'd8);  //任务的调用,任务名+括号中要传递进任务的参数
        rx_bit(8'd1);
        rx_bit(8'd2);
        rx_bit(8'd3);
        rx_bit(8'd4);
        rx_bit(8'd5);
        rx_bit(8'd6);
        rx_bit(8'd7);
end
    
 
//定义一个名为rx_bit的任务
//任务以task开头,后面紧跟的是任务名,调用时使用
task rx_bit(
    //传递到任务中的参数,调用任务的适合从外部传进来一个8位的值
        input   [7:0]   data
);
    
        integer i;      //定义一个常量
        
        for(i=0; i<10; i=i+1) begin
            case(i)
                0: rx <= 1'b0;
                1: rx <= data[0];
                2: rx <= data[1];
                3: rx <= data[2];
                4: rx <= data[3];
                5: rx <= data[4];
                6: rx <= data[5];
                7: rx <= data[6];
                8: rx <= data[7];
                9: rx <= 1'b1;
            endcase
            #(434*20);  //每发送1位数据时434个时钟周期
        end
endtask
 
uart_rx
#(
    .BAUD_MAX    ('d115_200     ),
    .CLK_MAX     ('d50_000_000  )
)
uart_rx_inst
(
    .sys_clk     (sys_clk  ),
    .sys_rst_n   (sys_rst_n),
    .rx          (rx       ),
                           
    .po_data     (po_data  ),
    .po_flag     (po_flag  )
    );
 
endmodule

打拍取沿及接收使能部分波形:

波特计数器以及比特标志位(434/2拉高)波形:

数据接收端以及数据接收完成标志位波形:

发送模块

同理按照时序图绘制发送模块的波形图:

因为设计一个串口回环,发送和接收模块的波特率是相同的,所以并没有队 pi_flag 信号进行打 3 拍处理。在接收信号拉高之后, tx_en 拉高,进入发送模式。

同样波特计数器为 434,bit_flag 每次拉高,bit_cnt 计一个数,第 0 位为起始位,拉低,然后进行数据的传送,当计数到第九位时,使 tx 信号拉高,表示停止位。

同样根据波形图可以编写出发送模块的代码:

UART_send.v:

module UART_send
#(
    parameter  CLK        =   26'd50000000    ,    // 时钟频率
    parameter  BAUD        =   17'd115200           // 波特率
)
(
    input   wire            clk         ,
    input   wire            rstn        ,   
    input   wire    [7 : 0] data_in     ,   // 需要发送的数据
    input   wire            flag_in     ,   // 数据接收标志位,既发送标志位

    output  reg             UART_tx         // 串口输出位         
);

    localparam Baud_Clk     =   CLK/BAUD       ;    // 传输每个 Baud 需要的时钟数

    reg             tx_en       ;   // 发送使能
    reg             flag_bit    ;   // 比特标志位,采用下降沿发送
    reg [8 : 0]     cnt_baud    ;   // 波特率计数器
    reg [3 : 0]     cnt_bit     ;   // 比特计数器

    // 发送使能
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            tx_en <= 1'b0;
        end
        // 已经发送了十位 bit 并且到达下一个下降沿,输入只需要判断到数据位最后一位,输出则需要判断完整输出
        else if(cnt_bit == 4'd9 && flag_bit == 1'b1) begin
            tx_en <= 1'b0;
        end
        else if(flag_in == 1'b1) begin
            tx_en <= 1'b1;
        end
    end

    // 波特计数器
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            cnt_baud <= 9'd0;
        end
        // 传输完成所有波特或者使能失效,表示发送结束
        else if(cnt_baud == Baud_Clk - 1'b1 || tx_en == 1'b0) begin
            cnt_baud <= 9'd0;
        end
        else begin
            cnt_baud <= cnt_baud + 9'd1;
        end
    end

    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            flag_bit <= 1'b0;
        end
        // 只有刚开始发送的一瞬间会产生一个时钟周期上升沿和下降沿
        else if(cnt_baud == 9'd1) begin
            flag_bit <= 1'b1;
        end
        else begin
            flag_bit <= 1'b0;
        end
    end

    // 计数10分有效数据位
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            cnt_bit <= 4'd0;
        end
        // 已经发送了十位 bit 并且到达下一个下降沿
        else if(cnt_bit == 4'd9 && flag_bit == 1'b1) begin
            cnt_bit <= 4'd0;
        end
        // 使能有效,下降沿发送数据
        else if(flag_bit == 1'b1 && tx_en == 1'b1) begin
            cnt_bit <= cnt_bit + 4'd1;
        end
        else begin
            cnt_bit <= cnt_bit;
        end
    end

    // 满足 RS232 协议 起始位为 0,停止位为 1,并按位输出
    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            UART_tx <= 1'd1;
        end
        // 下降沿发送数据
        else if(flag_bit == 1'b1) begin
            case (cnt_bit)
                0:       UART_tx <= 1'd0        ;
                1:       UART_tx <= data_in[0]  ;
                2:       UART_tx <= data_in[1]  ;
                3:       UART_tx <= data_in[2]  ;
                4:       UART_tx <= data_in[3]  ;
                5:       UART_tx <= data_in[4]  ;
                6:       UART_tx <= data_in[5]  ;
                7:       UART_tx <= data_in[6]  ;
                8:       UART_tx <= data_in[7]  ;
                9:       UART_tx <= 1'd1        ;
                default: UART_tx <= 1'd1        ;
            endcase
        end
    end

endmodule //UART_send

同样进行发送代码的仿真编写:

tb_uart_tx.v:

`timescale 1ns / 1ns
 
module tb_uart_tx();
 
reg                sys_clk     ;
reg                sys_rst_n   ;                             
reg       [7:0]    pi_data     ;
reg                pi_flag     ;
        
wire               tx          ;
 
 
initial begin
    sys_clk = 1'b0;
    sys_rst_n <= 1'b0;
    #201
    sys_rst_n <= 1'b1;
end
 
 
always #10 sys_clk = ~sys_clk;
 
initial begin
    pi_flag <= 1'b0;
    pi_data <= 8'd0;
    #401
    pi_data <= 8'd0;
    pi_flag <= 1'd1;
    #20
    pi_flag <= 1'd0;
    #(434*10*20)
    pi_data <= 8'd15;
    pi_flag <= 1'd1;
    #20
    pi_flag <= 1'd0;
    #(434*10*20)
    pi_data <= 8'd2;
    pi_flag <= 1'd1;
    #20
    pi_flag <= 1'd0;
    #(434*10*20)
    pi_data <= 8'd3;
    pi_flag <= 1'd1;
    #20
    pi_flag <= 1'd0;
    #(434*10*20)
    pi_data <= 8'd4;
    pi_flag <= 1'd1;
    #20
    pi_flag <= 1'd0;
    #(434*10*20)
    pi_data <= 8'd5;
    pi_flag <= 1'd1;
    #20
    pi_flag <= 1'd0;
    #(434*10*20)
    pi_data <= 8'd6;
    pi_flag <= 1'd1;
    #20
    pi_flag <= 1'd0;
    #(434*10*20)
    pi_data <= 8'd7;
    pi_flag <= 1'd1;
    #20
    pi_flag <= 1'd0;
end
 
uart_tx
#(
    .BAUD_MAX('d115_200     )       ,
    .CLK_MAX ('d50_000_000  )
)uart_tx_inst
(
    .sys_clk     (sys_clk  ),
    .sys_rst_n   (sys_rst_n),
                           
    .pi_data     (pi_data  ),
    .pi_flag     (pi_flag  ),
                           
    .tx          (tx       )
);
 
endmodule

先看一下发送开始标志位波形:

延迟一个时钟周期,发送使能拉高:

波特计数器等于 1 是,比特标志位拉高,比特位数加 1:

如接收到的数据为 7,发送端从最低位 1110_0000 发送数据 7,注意这里的顺序是先发送最低位,最后一位为最高位

例化回环模块

最后将我们的两个模块例化到一起:

UART.v:

module UART (
    input   wire            clk         ,
    input   wire            rstn        ,
    input   wire            UART_rx     ,

    output  wire            UART_tx         
);

    localparam   CLK_50MHz   =   26'd50000000    ;    // 时钟频率
    localparam   BAUD        =   17'd115200      ;    // 波特率

    wire    [7:0]   data    ;
    wire            flag    ;

    UART_send
    #(
        .CLK         (CLK_50MHz ),// 时钟频率
        .BAUD        (BAUD      ) // 波特率
    )
    UART_send_init(
        .clk         (clk       ),
        .rstn        (rstn      ),   
        .data_in     (data      ),   // 需要发送的数据
        .flag_in     (flag      ),   // 数据接收标志位,既发送标志位
        .UART_tx     (UART_tx   )    // 串口输出位         
    );

    UART_recv 
    #(
        .CLK         (CLK_50MHz ),    // 时钟频率
        .BAUD        (BAUD      )     // 波特率
    )
    UART_recv_init(
        .clk         (clk       ),
        .rstn        (rstn      ),   
        .UART_rx     (UART_rx   ),
        .flag_out    (flag      ),   // 数据接收完成标志位,既发送开始标志位,半个时钟周期为 1 ,用于判断数据已经全部接收完成
        .data_out    (data      )    // 接收的数据
    );

endmodule //UART

烧录效果演示

串口发送多字节数据

这里我们采用发送多字节的方式进行发送,前面我们已经介绍了 FPGA 如何使用超声波并显示在数码管上,这里讲超声波距离数据通过串口发送到上位机,这里超声波距离保留三位小数,格式如下:xxx.xxxcm

这里我们通过数据处理后,转为 ASCII,然后我们每次发送一位,按照我们上面给定的格式,整个数据共有 9 位,有由于我们需要每分钟发送一次数据,所以我们需要每分钟发送 10 个数据

有些朋友可能会问,我们只有 9 位数据,为什么要发送 10 位?

这是因为我们由于要使用 python 程序接收数据,所以我们需要在数据最后发送换行表示一次数据发送完成

数据处理代码如下:

UART_driver.v:

module UART_driver (
    input   wire            clk         ,
    input   wire            rstn        ,
    input   wire    [18:0]  data_in     , 
    input   wire            UART_rx     ,

    output  wire            UART_tx         
);

    localparam   CLK_50MHz   =   26'd50000000    ;    // 时钟频率
    localparam   BAUD        =   17'd115200      ;    // 波特率

    reg     [7:0]   data    ;
    wire            flag    ;
    wire            tx_done ;   
    wire             flag_0    ;    // 未启动超声波

    reg     [25:0]      cnt_clk         ;  
    reg     [3:0]       xcnt            ;
    reg     [71: 0]     data_out        ;   // 最终发送的数据

    reg        [3:0]        cm_hund            ;//100cm
    reg        [3:0]        cm_ten            ;//10cm
    reg        [3:0]        cm_unit            ;//1cm
    reg        [3:0]        point_1            ;//1mm
    reg        [3:0]        point_2            ;//0.1mm
    reg        [3:0]        point_3            ;//0.01mm

    localparam
        byte0  = "0",
        byte1  = "1",
        byte2  = "2",
        byte3  = "3",
        byte4  = "4",
        byte5  = "5",
        byte6  = "6",
        byte7  = "7",
        byte8  = "8",
        byte9  = "9",
        byte10 = "\n";

    always@(posedge clk or negedge rstn) begin
        if(!rstn)
            xcnt <= 0;
        else if(tx_done)
            xcnt <= xcnt + 1'd1;
        else if(xcnt == 10)
            xcnt <= 0;
    end

    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin
            cnt_clk <= 0;
        end
        else if(flag) begin
            cnt_clk <= 0;
        end
        else begin
            cnt_clk = cnt_clk + 1;
        end
    end

    assign flag     = cnt_clk == CLK_50MHz/11 - 1;    // 一秒钟发送所有数据
    assign flag_0    = cm_hund == 0 && cm_ten == 0 && cm_unit == 0 && point_1 == 0 && point_2 == 0 && point_3 == 0;

    always @(posedge clk or negedge rstn)begin  
        if(!rstn)begin  
            cm_hund    <= 'd0;
            cm_ten    <= 'd0;
            cm_unit    <= 'd0;
            point_1    <= 'd0;
            point_2    <= 'd0;
            point_3    <= 'd0;
        end  
        else begin  
            cm_hund <= data_in % 10;
            cm_ten    <= data_in / 10 ** 1 % 10;
            cm_unit <= data_in / 10 ** 2 % 10;
            point_1 <= data_in / 10 ** 3 % 10;
            point_2 <= data_in / 10 ** 4 % 10;
            point_3 <= data_in / 10 ** 5 % 10;
        end  
    end 

    always @(*) begin
        case (xcnt)
            0    :    data = hex_data(point_3);
            1    :    data = hex_data(point_2);
            2    :    data = hex_data(point_1);
            3    :    data = "."              ;
            4    :    data = hex_data(cm_unit);
            5    :    data = hex_data(cm_ten) ;
            6    :    data = hex_data(cm_hund);
            7    :    data = "c"              ;
            8    :    data = "m"              ;
            9    :    data = "\n"             ;
            default:    data = 6'h30;
        endcase
    end

    // 函数,4位输入,7位输出,判断要输出的数字
    function  [7:0]    hex_data; //函数不含时序逻辑相关
        input   [03:00]    data_i;//至少一个输入
        begin
            case(data_i)
                4'd0:hex_data = 6'h30;
                4'd1:hex_data = 6'h31;
                4'd2:hex_data = 6'h32;
                4'd3:hex_data = 6'h33;
                4'd4:hex_data = 6'h34;
                4'd5:hex_data = 6'h35;
                4'd6:hex_data = 6'h36;
                4'd7:hex_data = 6'h37;
                4'd8:hex_data = 6'h38;
                4'd9:hex_data = 6'h39;
                default:hex_data = 6'h30;
            endcase    
        end 
    endfunction

    UART_send
    #(
        .CLK         (CLK_50MHz ),// 时钟频率
        .BAUD        (BAUD      ) // 波特率
    )
    UART_send_init(
        .clk         (clk       ),
        .rstn        (rstn      ),   
        .data_in     (data      ),   // 需要发送的数据
        .flag_in     (flag      ),   // 数据接收标志位,既发送标志位
        .UART_tx     (UART_tx   ),   // 串口输出位         
        .tx_done     (tx_done   )  
    );

endmodule //UART

python 接收串口多字节数据

这里我们选择 python 语言作为上位机数据处理语言

开始的时候,我们运行数据处理程序,但是并不知道板子上已经发送到哪一位数据,所以我们需要循环过滤掉第一次接收到的数据:

while True:
    if ser.in_waiting:
        data = ser.read(ser.in_waiting)
        if str(data,encoding="utf-8") == '\n':
            break

然后我们就可以循环接收串口数据:

while True:
    if ser.in_waiting:  # 如果串口接收到了数据
        data = ser.read(ser.in_waiting)  # 读取所有可用的数据
        num_chars = len(data)  # 获取收到的字符个数
        num_all = num_all + num_chars
        if num_all <= 7:
           char = char + str(data , encoding = "utf-8")
        elif num_all == 10:
            # distance = float(char)
            if char != "No Data":
                distance = float(char)
            # print(char[0:7])
            print("距离:",distance,"cm")
            char = ""
            num_all = 0
        # print(f"收到 {num_chars} 个字符:{data}")
        # print(data)

ser.close()  # 关闭串口

完整 python 代码如下:

import serial

ser = serial.Serial('COM22', 115200)  # 假设您的串口是 COM1,波特率为 9600
ser.flushInput()  # 清空输入缓冲区

num_all = 0
char = ""

while True:
    if ser.in_waiting:
        data = ser.read(ser.in_waiting)
        if str(data,encoding="utf-8") == '\n':
            break
while True:
    if ser.in_waiting:  # 如果串口接收到了数据
        data = ser.read(ser.in_waiting)  # 读取所有可用的数据
        num_chars = len(data)  # 获取收到的字符个数
        num_all = num_all + num_chars
        if num_all <= 7:
           char = char + str(data , encoding = "utf-8")
        elif num_all == 10:
            # distance = float(char)
            if char != "No Data":
                distance = float(char)
            # print(char[0:7])
            print("距离:",distance,"cm")
            char = ""
            num_all = 0
        # print(f"收到 {num_chars} 个字符:{data}")
        # print(data)

ser.close()  # 关闭串口

烧录效果演示

标签: fpga开发

本文转载自: https://blog.csdn.net/m0_59161987/article/details/131079669
版权归原作者 ppqppl 所有, 如有侵权,请联系我们删除。

“FPGA入门 —— FPGA UART 串口通信”的评论:

还没有评论