界面与串口 on 扎塔-Zata

PyQt-设备像素设置

Thu, 24 Apr 2025 11:06:37 +0800

让Qt应用在高DOI或者高分辨率显示器上看起来更加清晰（最新pyqt6已经不需要设置）

QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True) QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)

目的

这两行代码的目的是让你的 Qt 应用程序在高 DPI（Dots Per Inch，每英寸点数）或高分辨率显示器（例如 Retina 屏、4K 显示器）上看起来更清晰、大小更合适。

代码解释

QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
- QApplication: 这是你的 Qt 应用程序的核心类。
- setAttribute: 这是设置应用程序级别属性的方法。
- Qt.AA_EnableHighDpiScaling: 这是一个枚举值（属性标志）。当它被设置为 True 时，它告诉 Qt 启用基于显示器 DPI 的自动缩放。这意味着 Qt 会尝试自动调整窗口、控件（按钮、文本框等）的大小以及字体大小，使它们在不同 DPI 的屏幕上看起来比例一致。
- True: 启用这个属性。
QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
- Qt.AA_UseHighDpiPixmaps: 这是另一个属性标志。当它被设置为 True 时，它告诉 Qt 在高 DPI 显示器上使用高分辨率版本的像素图（pixmaps），也就是图标和图片。如果你为图标提供了 @2x 或类似的高分辨率版本（例如 icon.png 和 icon@2x.png），设置此项能让 Qt 自动选择合适的版本，从而在高 DPI 屏幕上显示清晰的图标，而不是模糊的低分辨率版本。
- True: 启用这个属性。

何时以及如何使用

这两行代码非常重要的一点是：它们必须在创建 QApplication 实例之前被调用。因为它们影响应用程序如何初始化以及如何与操作系统的显示设置交互。

简单示例 (以 PyQt5 为例)

import sys

# 导入你需要的 PyQt 或 PySide 模块
# 可能是 PyQt5, PyQt6, PySide2, PySide6
# 这里以 PyQt6 为例
# from PyQt6.QtWidgets import QApplication, QWidget, QLabel, QVBoxLayout
# from PyQt6.QtCore import Qt # Qt 模块包含枚举值


from PyQt5.QtWidgets import (
 QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
 QTabWidget, QAction, QFileDialog, QMessageBox,
 QSplitter, QToolBar, QStatusBar, QLabel, QComboBox,QApplication
)
from PyQt5.QtCore import Qt


# --- 关键步骤 ---
# 在创建 QApplication 实例之前设置高 DPI 属性
# 注意: 在 Qt 6 已经自动支持了， 所以不需要单独写代码



# 在 Qt 5 中，通常直接是 Qt.AA_...
# 设置高 DPI 支持
# PyQt5 需要显式启用高 DPI 缩放
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
# --- 关键步骤结束 ---

# 创建 QApplication 实例
# sys.argv 允许你传递命令行参数给应用程序
app = QApplication(sys.argv)

# 创建一个简单的窗口
window = QWidget()
window.setWindowTitle('高 DPI 示例')

# 添加一些控件
layout = QVBoxLayout()
label = QLabel('这个标签在高 DPI 屏幕上应该看起来很清晰。')
layout.addWidget(label)
window.setLayout(layout)

# 设置窗口大小并显示
window.resize(300, 150)
window.show()

# 启动应用程序的事件循环
# 程序会在这里等待用户交互，直到窗口关闭
sys.exit(app.exec())

总结

为了让你的 PyQt/PySide 应用在现代高分辨率屏幕上获得良好的视觉效果（避免元素过小或图像模糊），请在创建 QApplication 对象之前添加这两行代码（pyqt5）。
AA_EnableHighDpiScaling 主要负责 UI 元素（控件、字体、布局）的缩放。
AA_UseHighDpiPixmaps 主要负责图像和图标的清晰度。

在较新的 Qt 版本（尤其是 Qt 6）中，AA_EnableHighDpiScaling 可能已经是默认启用的，但显式设置它是一个好的实践，可以确保跨版本和平台的兼容性。而 AA_UseHighDpiPixmaps 通常仍然需要显式设置以加载高分辨率图像资源。

设备像素比

除了之前提到的 AA_EnableHighDpiScaling 和 AA_UseHighDpiPixmaps 这两个用于自动处理高 DPI 的应用程序属性之外，还有一些相关的函数和概念，它们允许你查询 DPI 信息或进行更手动的控制。

最接近且常用的相关功能是查询设备像素比 (Device Pixel Ratio)。

核心概念：设备像素比 (Device Pixel Ratio)

定义：设备像素比是指物理像素（屏幕上实际的光点）与设备无关像素（也称为逻辑像素，是应用程序绘制时使用的标准坐标单位，通常基于 96 DPI）之间的比例。
意义：
- 在标准 DPI 显示器上，这个比例通常是 1.0。
- 在高 DPI 显示器（如 Retina 或 4K 屏）上，这个比例会大于 1.0（例如 1.5, 2.0, 2.5 等），表示一个逻辑像素对应了多个物理像素。
用途：你可以使用这个比率来：
1. 手动缩放：在需要精确控制像素的情况下（例如自定义绘图 paintEvent），将逻辑坐标或尺寸乘以这个比率来得到物理像素尺寸。
2. 加载资源：根据比率选择不同分辨率的图像资源（虽然 AA_UseHighDpiPixmaps 通常会自动处理）。
3. 调试：检查应用程序当前的缩放状态。

相关函数和类

QWidget.devicePixelRatio() -> int / QWidget.devicePixelRatioF() -> float
- 获取控件（Widget）当前所在屏幕的设备像素比。
- 返回整数版本 (devicePixelRatio) 或更精确的浮点数版本 (devicePixelRatioF)。
- 这是最常用的，因为它直接关联到你正在操作的那个窗口或控件。
QScreen 类
- 代表一个物理显示屏幕。
- QGuiApplication.primaryScreen(): 获取系统的主屏幕对象。
- QWidget.screen(): 获取控件当前所在的 QScreen 对象。
- QScreen.devicePixelRatio() -> float: 获取这个特定屏幕的设备像素比。
- QScreen.logicalDotsPerInch() -> float: 获取屏幕的逻辑 DPI (通常是 96 DPI，但也可能被系统设置为其他值)。
- QScreen.physicalDotsPerInch() -> float: 获取屏幕的物理 DPI (实际硬件的像素密度)。
- QScreen.geometry() -> QRect: 获取屏幕的几何尺寸（使用逻辑像素）。
- QScreen.availableGeometry() -> QRect: 获取屏幕的可用几何尺寸（排除任务栏等，使用逻辑像素）。

教程和示例

下面的示例展示了如何获取窗口和屏幕的设备像素比以及其他相关信息，并包含了一个简单的自定义绘图控件，演示如何在 paintEvent 中考虑像素比。

import sys
from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QLabel,
 QVBoxLayout, QTextEdit)
# QGuiApplication 用于获取屏幕信息
from PyQt6.QtGui import QGuiApplication, QPainter, QColor, QFont, QPaintEvent
from PyQt6.QtCore import Qt, QRectF, QSize

# --- 依然建议先设置自动缩放属性 ---
# 这让 Qt 框架自动处理大部分 UI 元素的缩放
try:
 # Qt 6 风格
 QApplication.setAttribute(Qt.ApplicationAttribute.AA_EnableHighDpiScaling, True)
 QApplication.setAttribute(Qt.ApplicationAttribute.AA_UseHighDpiPixmaps, True)
except AttributeError:
 # Qt 5 风格
 QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
 QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
# ---

# 自定义绘图控件，演示如何在 paintEvent 中使用 devicePixelRatio
class DrawingWidget(QWidget):
 def minimumSizeHint(self) -> QSize:
 # 提供一个基于逻辑像素的最小尺寸提示
 return QSize(200, 100)

 # 重写 paintEvent 进行自定义绘图
 def paintEvent(self, event: QPaintEvent):
 painter = QPainter(self)
 painter.setRenderHint(QPainter.RenderHint.Antialiasing) # 让绘制更平滑

 # 获取当前控件的设备像素比 (浮点数版本更精确)
 ratio = self.devicePixelRatioF()

 # 准备绘制信息
 text = f"Device Pixel Ratio: {ratio:.2f}"
 logical_rect = QRectF(10.0, 10.0, 180.0, 50.0) # 使用逻辑像素定义矩形

 # 绘制背景矩形 (QPainter 默认使用逻辑坐标)
 painter.setBrush(QColor(230, 240, 255)) # 淡蓝色背景
 painter.setPen(Qt.PenStyle.NoPen) # 无边框
 painter.drawRoundedRect(logical_rect, 5.0, 5.0) # 圆角矩形

 # 绘制文字 (QPainter 会根据 Qt 的缩放设置自动处理字体大小)
 # 但如果你需要基于物理像素精确控制，可能需要手动计算
 painter.setPen(QColor("black"))
 font = QFont()
 # 你可以尝试设置逻辑点大小，Qt 会处理缩放
 font.setPointSizeF(10)
 painter.setFont(font)

 # 在矩形内绘制文本 (文本位置也是逻辑坐标)
 painter.drawText(logical_rect.adjusted(5, 5, -5, -5), Qt.AlignmentFlag.AlignCenter, text)

 # 示例：如果需要绘制一个固定物理像素大小的线条 (需要手动计算)
 # 假设需要绘制一条 2 个物理像素宽的线
 physical_line_width = 2
 logical_line_width = physical_line_width / ratio # 计算对应的逻辑宽度

 pen = painter.pen() # 获取当前画笔
 pen.setColor(QColor("red"))
 pen.setWidthF(logical_line_width) # 设置逻辑宽度
 painter.setPen(pen)

 # 绘制线条 (坐标仍是逻辑像素)
 painter.drawLine(int(logical_rect.left()), int(logical_rect.bottom()) + 10,
 int(logical_rect.right()), int(logical_rect.bottom()) + 10)

 painter.end() # 结束绘制

# 主窗口类
class MainWindow(QMainWindow):
 def __init__(self):
 super().__init__()
 self.setWindowTitle("查询 DPI 和设备像素比")
 self.setGeometry(100, 100, 500, 450) # 初始位置和大小 (逻辑像素)

 # 用于显示信息的文本框
 self.info_display = QTextEdit()
 self.info_display.setReadOnly(True)
 self.info_display.setLineWrapMode(QTextEdit.LineWrapMode.NoWrap) # 不自动换行

 # 自定义绘图控件实例
 self.drawing_widget = DrawingWidget()

 # 布局
 central_widget = QWidget()
 layout = QVBoxLayout(central_widget)
 layout.addWidget(QLabel("信息查询结果:"))
 layout.addWidget(self.info_display)
 layout.addWidget(QLabel("自定义绘图区域:"))
 layout.addWidget(self.drawing_widget)

 self.setCentralWidget(central_widget)

 # 在窗口显示后查询信息会更可靠
 self.initial_query_done = False

 # 查询并显示 DPI 和屏幕信息
 def query_and_display_info(self):
 info = []

 # 1. 获取窗口自身的设备像素比
 # 注意: 最好在窗口实际显示到屏幕上之后获取 (例如在 showEvent 或 moveEvent 中)
 window_dpr = self.devicePixelRatio()
 window_dpr_f = self.devicePixelRatioF()
 info.append(f"--- 窗口 (Window) ---")
 info.append(f"devicePixelRatio(): {window_dpr} (int)")
 info.append(f"devicePixelRatioF(): {window_dpr_f:.2f} (float)")

 # 2. 获取窗口所在的屏幕信息
 current_screen = self.screen() # QWidget.screen() 获取当前屏幕
 if not current_screen:
 # 如果窗口还没显示或找不到屏幕，尝试获取主屏幕
 current_screen = QGuiApplication.primaryScreen()

 if current_screen:
 screen_name = current_screen.name()
 screen_dpr = current_screen.devicePixelRatio()
 logical_dpi_x = current_screen.logicalDotsPerInchX()
 logical_dpi_y = current_screen.logicalDotsPerInchY()
 physical_dpi_x = current_screen.physicalDotsPerInchX()
 physical_dpi_y = current_screen.physicalDotsPerInchY()
 geometry = current_screen.geometry() # 逻辑像素矩形
 available_geometry = current_screen.availableGeometry() # 可用逻辑像素矩形

 info.append(f"\n--- 当前屏幕 (Screen: {screen_name}) ---")
 info.append(f"devicePixelRatio(): {screen_dpr:.2f}")
 info.append(f"logicalDotsPerInch (X, Y): {logical_dpi_x:.1f}, {logical_dpi_y:.1f}")
 info.append(f"physicalDotsPerInch (X, Y): {physical_dpi_x:.1f}, {physical_dpi_y:.1f}")
 info.append(f"geometry (逻辑像素): {geometry.width()}x{geometry.height()} @ ({geometry.x()},{geometry.y()})")
 info.append(f"availableGeometry (逻辑像素): {available_geometry.width()}x{available_geometry.height()}")

 # 计算物理像素尺寸
 physical_width = geometry.width() * screen_dpr
 physical_height = geometry.height() * screen_dpr
 info.append(f"物理像素 (计算): {int(physical_width)}x{int(physical_height)}")
 else:
 info.append("\n无法获取屏幕信息。")

 self.info_display.setText("\n".join(info))
 # 更新自定义绘图区域，因为它依赖于 devicePixelRatio
 self.drawing_widget.update()

 # 重写 showEvent，在窗口首次显示时查询信息
 def showEvent(self, event):
 super().showEvent(event)
 if not self.initial_query_done:
 self.query_and_display_info()
 self.initial_query_done = True

 # 重写 moveEvent，当窗口移动（可能移动到不同 DPI 的屏幕）时更新信息
 def moveEvent(self, event):
 super().moveEvent(event)
 # 只有在窗口可见时移动才更新，避免初始化时多次调用
 if self.isVisible():
 self.query_and_display_info()

# --- 主程序入口 ---
app = QApplication(sys.argv)
main_window = MainWindow()
main_window.show()
sys.exit(app.exec())

代码解释

AA_ 属性设置：我们仍然保留了开头的 AA_EnableHighDpiScaling 和 AA_UseHighDpiPixmaps 设置，因为它们是让 Qt 框架自动处理大部分 UI 缩放的基础，推荐使用。
DrawingWidget：这是一个自定义控件，重写了 paintEvent。
- 在 paintEvent 内部，我们首先通过 self.devicePixelRatioF() 获取当前控件的设备像素比 ratio。
- 我们使用 QPainter 进行绘图。QPainter 的坐标系统默认是基于逻辑像素的。当你调用 drawRect, drawText 等函数时，你提供的坐标和尺寸是逻辑单位。
- Qt 的渲染引擎在启用了高 DPI 缩放后，会自动将这些逻辑坐标映射到物理像素上进行绘制。因此，对于标准的控件和文本绘制，你通常不需要手动乘以 ratio。
- 手动缩放场景：示例中演示了如果你需要绘制一个具有固定物理像素宽度的线条（例如 2 像素），你需要用物理宽度除以 ratio 得到对应的逻辑宽度，然后设置给 QPen。这是手动控制像素级细节的一个例子。
MainWindow：
- query_and_display_info 方法：
  - 获取窗口自身的 devicePixelRatio() 和 devicePixelRatioF()。
  - 通过 self.screen() 或 QGuiApplication.primaryScreen() 获取当前的 QScreen 对象。
  - 从 QScreen 对象获取更详细的信息，如屏幕的 devicePixelRatio, 逻辑 DPI, 物理 DPI, 几何尺寸（逻辑像素）等。
  - 计算并显示屏幕的物理像素尺寸。
- showEvent 和 moveEvent：重写这两个事件处理函数，确保在窗口首次显示或移动到新屏幕时，调用 query_and_display_info 来更新显示的信息，并触发 DrawingWidget 的重绘 (update())。

总结

AA_EnableHighDpiScaling 和 AA_UseHighDpiPixmaps 是实现自动高 DPI 适应性的关键属性，适用于大多数标准 UI 元素。
QWidget.devicePixelRatio(), QWidget.devicePixelRatioF() 和 QScreen 类及其方法允许你查询当前的缩放比例和屏幕信息。
查询到的 devicePixelRatio 对于需要手动控制像素级细节的场景（如自定义绘图、与需要物理像素坐标的库交互）非常有用。
对于标准的 QPainter 绘图操作，通常使用逻辑坐标即可，Qt 的自动缩放机制会处理好物理像素的映射。只有在需要精确控制物理尺寸或绘制像素对齐的图形时，才需要手动介入计算。

PyQt-入门教程（AI生成）

Thu, 24 Apr 2025 10:39:35 +0800

PyQt6 入门教程（详细版本）

PyQt6 是一个用于创建桌面应用程序的 Python 库，它是 Qt 框架的 Python 绑定。Qt 是一个功能强大的跨平台框架，支持 GUI 开发、网络编程、数据库操作等。通过 PyQt6，你可以轻松地开发跨平台的桌面应用程序。

本教程将从零开始，逐步引导你学习 PyQt6 的基本概念和使用方法。

一、环境准备

在开始之前，你需要确保你的开发环境已经安装了以下内容：

Python
确保你已经安装了 Python 3.6 或更高版本。可以通过以下命令检查：
```
python --version
```
安装 PyQt6
使用 pip 安装 PyQt6：
```
pip install PyQt6
```
安装 PyQt6 工具（可选）
如果你想使用 Qt Designer（一个可视化设计工具），可以安装 pyqt6-tools：
```
pip install pyqt6-tools
```
安装完成后，可以在 Scripts 目录下找到 designer.exe 文件，启动它即可使用 Qt Designer。

二、第一个 PyQt6 程序

让我们从一个简单的例子开始，创建一个窗口并显示它。

示例代码：Hello World

import sys
from PyQt6.QtWidgets import QApplication, QWidget

# 创建主程序类
class MyApp(QWidget):
 def __init__(self):
 super().__init__()
 self.initUI()

 def initUI(self):
 # 设置窗口标题
 self.setWindowTitle("Hello PyQt6")
 # 设置窗口大小
 self.setGeometry(100, 100, 400, 300)
 # 显示窗口
 self.show()

if __name__ == "__main__":
 # 创建应用实例
 app = QApplication(sys.argv)
 # 创建窗口实例
 window = MyApp()
 # 进入主循环
 sys.exit(app.exec())

代码解析

导入模块
- QApplication: 管理应用程序的控制流和主要设置。
- QWidget: 所有用户界面对象的基类。
创建自定义类
- MyApp 继承自 QWidget，我们在这里定义窗口的行为。
- __init__ 方法初始化窗口，并调用 initUI 方法设置界面。
设置窗口属性
- setWindowTitle: 设置窗口标题。
- setGeometry: 设置窗口的位置和大小（x, y, width, height）。
显示窗口
- 调用 show() 方法让窗口可见。
主程序入口
- 创建 QApplication 实例。
- 创建窗口实例并进入主事件循环。

运行上述代码后，你会看到一个标题为 “Hello PyQt6” 的窗口。

三、添加控件

在 PyQt6 中，你可以通过添加控件（如按钮、标签、文本框等）来丰富界面。

示例代码：带按钮的窗口

import sys
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QLabel

class MyApp(QWidget):
 def __init__(self):
 super().__init__()
 self.initUI()

 def initUI(self):
 # 设置窗口标题和大小
 self.setWindowTitle("Button Example")
 self.setGeometry(100, 100, 300, 200)

 # 创建垂直布局
 layout = QVBoxLayout()

 # 创建标签
 self.label = QLabel("Hello, PyQt6!", self)
 layout.addWidget(self.label)

 # 创建按钮
 button = QPushButton("Click Me", self)
 button.clicked.connect(self.on_button_click) # 绑定点击事件
 layout.addWidget(button)

 # 设置布局
 self.setLayout(layout)

 def on_button_click(self):
 # 修改标签文本
 self.label.setText("Button Clicked!")

if __name__ == "__main__":
 app = QApplication(sys.argv)
 window = MyApp()
 window.show()
 sys.exit(app.exec())

代码解析

控件介绍
- QLabel: 用于显示文本或图片。
- QPushButton: 按钮控件。
- QVBoxLayout: 垂直布局管理器，用于排列控件。
事件绑定
- button.clicked.connect(self.on_button_click) 将按钮的点击事件与自定义方法 on_button_click 绑定。
动态更新界面
- 在 on_button_click 方法中修改标签的文本内容。

运行代码后，点击按钮会触发事件，标签的内容会变为 “Button Clicked!"。

四、信号与槽机制

PyQt6 的核心之一是信号与槽机制（Signals and Slots）。信号是由控件发出的事件，槽是响应这些事件的函数。

示例代码：信号与槽

import sys
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QLineEdit, QVBoxLayout

class MyApp(QWidget):
 def __init__(self):
 super().__init__()
 self.initUI()

 def initUI(self):
 self.setWindowTitle("Signal and Slot Example")
 self.setGeometry(100, 100, 300, 200)

 # 创建垂直布局
 layout = QVBoxLayout()

 # 创建输入框
 self.input_box = QLineEdit(self)
 layout.addWidget(self.input_box)

 # 创建按钮
 button = QPushButton("Show Text", self)
 button.clicked.connect(self.show_text) # 绑定点击事件
 layout.addWidget(button)

 # 设置布局
 self.setLayout(layout)

 def show_text(self):
 # 获取输入框内容并显示
 text = self.input_box.text()
 print(f"Input Text: {text}")

if __name__ == "__main__":
 app = QApplication(sys.argv)
 window = MyApp()
 window.show()
 sys.exit(app.exec())

代码解析

QLineEdit
- 用于接收用户输入的单行文本框。
信号与槽
- button.clicked.connect(self.show_text) 将按钮的点击信号连接到 show_text 方法。
- 在 show_text 方法中，通过 self.input_box.text() 获取输入框的内容。

运行代码后，在输入框中输入内容并点击按钮，控制台会打印出输入的文本。

五、使用 Qt Designer 设计界面

对于复杂的界面，手动编写代码可能效率较低。这时可以使用 Qt Designer 来设计界面，然后将其转换为 Python 代码。

步骤

打开 Qt Designer
启动 designer.exe，创建一个新的窗口或对话框。
设计界面
拖拽控件到窗口中，设置控件属性。
保存 .ui 文件
将设计好的界面保存为 .ui 文件。
使用 pyuic6 转换为 Python 代码
在终端中运行以下命令：
```
pyuic6 your_file.ui -o your_file.py
```

加载 .ui 文件
也可以直接在代码中加载 .ui 文件：

from PyQt6.uic import loadUi
from PyQt6.QtWidgets import QMainWindow, QApplication
import sys

class MainWindow(QMainWindow):
 def __init__(self):
 super().__init__()
 loadUi("your_file.ui", self)

if __name__ == "__main__":
 app = QApplication(sys.argv)
 window = MainWindow()
 window.show()
 sys.exit(app.exec())

六、总结

通过本教程，你应该已经掌握了以下内容：

如何安装 PyQt6 和相关工具。
创建一个简单的窗口并添加控件。
使用信号与槽机制处理用户交互。
使用 Qt Designer 快速设计界面。

接下来，你可以尝试更复杂的项目，例如多窗口应用、数据绑定、文件操作等。PyQt6 提供了丰富的功能，适合开发各种类型的桌面应用程序。祝你学习愉快！

pyserial-使用教程

Thu, 03 Apr 2025 10:15:25 +0800

基础教程

1. 安装 pyserial

首先，你需要安装 pyserial 库。可以通过 pip 安装：

pip install pyserial

2. 基本概念

串口通信（Serial Communication）是通过串行端口（如 USB 转串口设备、COM 端口等）进行数据传输的一种方式。常见用途包括与微控制器（如 Arduino）、传感器或其他硬件设备通信。

在 Python 中，pyserial 提供了一个简单的接口来操作串口。

3. 基础代码示例

以下是一个简单的示例，展示如何打开串口、发送数据和接收数据：

import serial
import time

# 配置串口参数
port = 'COM3' # Windows 示例，Linux/Mac 可能是 '/dev/ttyUSB0'
baudrate = 9600 # 波特率，根据设备设置
timeout = 1 # 读取超时时间（秒）

# 初始化串口
try:
 ser = serial.Serial(
 port=port,
 baudrate=baudrate,
 timeout=timeout
 )
 print(f"已连接到 {port}")
except serial.SerialException as e:
 print(f"连接失败: {e}")
 exit()

# 发送数据
message = "Hello, Serial!\n"
ser.write(message.encode('utf-8')) # 将字符串编码为字节并发送
print(f"已发送: {message.strip()}")

# 接收数据
time.sleep(1) # 等待一秒，确保有数据返回
if ser.in_waiting > 0: # 检查是否有数据在缓冲区
 data = ser.readline().decode('utf-8').strip() # 读取一行并解码
 print(f"收到: {data}")

# 关闭串口
ser.close()
print("串口已关闭")

4. 代码解释

serial.Serial(): 创建一个串口对象，参数包括端口号、波特率和超时时间。
port: 串口名称。Windows 上是 COMx（如 COM3），Linux/Mac 上是 /dev/ttyUSBx 或 /dev/ttySx。
baudrate: 数据传输速率，常见值有 9600、115200 等，需与设备一致。
timeout: 读取超时，避免程序无限等待。
write(): 发送数据，需将字符串编码为字节（如 encode('utf-8')）。
readline(): 读取一行数据（以换行符 \n 结束）。
in_waiting: 检查缓冲区是否有数据。

5. 如何找到串口号

在连接设备后，你需要知道设备的串口号。可以用以下代码列出所有可用串口：

import serial.tools.list_ports

ports = serial.tools.list_ports.comports()
for port in ports:
 print(f"端口: {port.device}, 描述: {port.description}")

运行后会显示类似：

端口: COM3, 描述: USB Serial Port (COM3)
端口: COM1, 描述: Communications Port (COM1)

根据描述选择正确的端口。

6. 常见问题与解决

端口被占用: 确保没有其他程序（如 Arduino IDE 的串口监视器）占用端口。
波特率不匹配: 确认波特率与设备一致。
无数据返回: 检查设备是否正确连接并发送数据。

7. 高级示例：持续读取数据

以下是一个循环读取串口数据的示例：

import serial
import time

ser = serial.Serial('COM3', 9600, timeout=1)

try:
 while True:
 if ser.in_waiting > 0:
 data = ser.readline().decode('utf-8').strip()
 print(f"收到: {data}")
 time.sleep(0.1) # 短暂休眠，避免占用过多 CPU
except KeyboardInterrupt:
 print("程序终止")
finally:
 ser.close()
 print("串口已关闭")

8. 与硬件交互示例（如 Arduino）

假设 Arduino 运行以下代码：

void setup() {
 Serial.begin(9600);
}

void loop() {
 if (Serial.available() > 0) {
 String msg = Serial.readString();
 Serial.println("收到: " + msg);
 }
}

Python 端可以这样与之交互：

import serial
import time

ser = serial.Serial('COM3', 9600, timeout=1)
time.sleep(2) # 等待 Arduino 重启

ser.write("Test\n".encode('utf-8'))
time.sleep(1)

if ser.in_waiting > 0:
 response = ser.readline().decode('utf-8').strip()
 print(response) # 输出: 收到: Test

ser.close()

9. 更多资源

官方文档: pyserial 文档
示例项目: 搜索 “Python serial Arduino” 可找到更多与硬件交互的案例。

代码实战

发送命令，随后接收数据，校验，重发

def set_current(port, current):
 """设置镀膜电流"""
 global_logger.info(f"开始设置镀膜电流 - 端口: {port}, 电流值: {current}")
 ready = SerialReader(port=port, baudrate=baudrate_global)
 command = f"CMD05,{current}\n"
 global_logger.info(f"发送设置电流命令: {command.strip()}")

 retry_count = 0
 max_retries = 2
 while retry_count <= max_retries:
 response = ready.send_command(command)
 start_time = time.time()
 while time.time() - start_time < 3:
 if response and response.strip() == "CMD05":
 global_logger.info(f"设置镀膜电流成功 - 响应: {response.strip()}")
 expected_response = f"CMD05,{current}"
 if expected_response.strip() in response.strip():
 global_logger.info("命令响应一致，设置成功")
 return True
 else:
 global_logger.warning(f"命令响应不一致 - 期望: {expected_response}, 实际: {response.strip()}")
 # 显示成功消息框
 messagebox.showinfo("命令响应不一致", f" 期望: {expected_response}, 实际: {response.strip()}")
 return False
 time.sleep(0.1)
 response = ready.read_data()
 retry_count += 1

 if retry_count > max_retries:
 global_logger.warning("设置镀膜电流失败 - 无响应")
 return False

界面与串口 on 扎塔-Zata

PyQt-设备像素设置

让Qt应用在高DOI或者高分辨率显示器上看起来更加清晰 （最新pyqt6已经不需要设置）

设备像素比

PyQt-入门教程（AI生成）

PyQt6 入门教程（详细版本）

一、环境准备

二、第一个 PyQt6 程序

示例代码：Hello World

代码解析

三、添加控件

示例代码：带按钮的窗口

代码解析

四、信号与槽机制

示例代码：信号与槽

代码解析

五、使用 Qt Designer 设计界面

步骤

六、总结

pyserial-使用教程

基础教程

1. 安装 pyserial

2. 基本概念

3. 基础代码示例

4. 代码解释

5. 如何找到串口号

6. 常见问题与解决

7. 高级示例：持续读取数据

8. 与硬件交互示例（如 Arduino）

9. 更多资源

代码实战

发送命令，随后接收数据，校验，重发

让Qt应用在高DOI或者高分辨率显示器上看起来更加清晰（最新pyqt6已经不需要设置）