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 协议：
- RS232 是 UART 的一种，没有时钟线，只有两根数据线，分别是 rx 和 tx，这两根线都是 1bit 位宽的。其中 rx 是接收数据的线， tx 是发送数据的线
- rx 位宽为 1bit， PC 机通过串口调试助手往 FPGA 发 8bit 数据时， FPGA 通过串口线rx 一位一位地接收，从最低位到最高位依次接收，最后在 FPGA 里面位拼接成 8 比特数据，也就是我们常说的串转并
- tx 位宽为 1bit， FPGA 通过串口往 PC 机发 8bit 数据时， FPGA 把 8bit 数据通过 tx线一位一位的传给 PC 机，从最低位到最高位依次发送，最后上位机通过串口助手按照RS232 协议把这一位一位的数据位拼接成 8bit 数据，并行数据转换成串行数据进行发送
- 串口数据的发送与接收是基于帧结构的，即一帧一帧的发送与接收数据。每一帧除了中间包含 8bit 有效数据外，还在每一帧的开头都必须有一个起始位，且固定为 0；在每一帧的结束时也必须有一个停止位，且固定为 1，即最基本的帧结构(不包括校验等)有10bit。在不发送或者不接收数据的情况下， rx 和 tx 处于空闲状态，此时 rx 和 tx 线都保持高电平，如果有数据帧传输时，首先会有一个起始位，然后是 8bit 的数据位，接着有 1bit的停止位，然后 rx 和 tx 继续进入空闲状态，然后等待下一次的数据传输
rs232时序图入下图所示：
- 波特率：在信息传输通道中，携带数据信息的信号单元叫码元(因为串口是 1bit 进行传输的，所以其码元就是代表一个二进制数)， 每秒钟通过信号传输的码元数称为码元的传输速率，简称波特率，常用符号“Baud”表示，其单位为“波特每秒(Bps)”。串口常见的波特率有 4800、9600、 115200 等
- 比特率：每秒钟通信信道传输的信息量称为位传输速率，简称比特率，其单位为“每秒比特数(bps)”。比特率可由波特率计算得出，公式为：比特率=波特率 * 单个调制状态对应的二进制位数。如果使用的是 115200 的波特率，其串口的比特率为： 115200Bps *1bit= 115200bps
- 由计算得串口发送或者接收 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 所有， 如有侵权，请联系我们删除。
版权归原作者 ppqppl 所有， 如有侵权，请联系我们删除。