Linux可以：





```shell
pip install cpython
pip install git+git://github.com/gatagat/lap.git
```

windows可以：

下载`https://github.com/gatagat/lap` 后解压，

安装`pip install cpython`

安装VS2019企业版：

```shell
key
BF8Y8-GN2QH-T84XB-QVY3B-RC4DF
```

执行安装：

```
(py38) C:\Users\xjsd>cd C:\Users\xjsd\Downloads\lap-master\lap-master
(py38) C:\Users\xjsd\Downloads\lap-master\lap-master>python setup.py install
```

![在这里插入图片描述](/static/img/images/03935.png)

也可以：

```
pip install . # 安装当前路径的包
```

完成后：

![在这里插入图片描述](/static/img/images/03936.png)

又发现新版不好用，下个`https://github.com/gatagat/lap/tree/v0.4.0` 老版本的。

Python，如何安装lap，pip安装lap出现问题

CUDA可用，共有 1 个GPU设备可用。





当前使用的GPU设备索引：0

当前使用的GPU设备名称：NVIDIA T1000

GPU显存总量：4.00 GB

已使用的GPU显存：0.00 GB

剩余GPU显存：4.00 GB

PyTorch版本：1.10.1+cu102

```python
import torch
# 检查CUDA是否可用
cuda_available = torch.cuda.is_available()
if cuda_available:
    # 获取GPU设备数量
    num_gpu = torch.cuda.device_count()
    # 获取当前使用的GPU索引
    current_gpu_index = torch.cuda.current_device()
    # 获取当前GPU的名称
    current_gpu_name = torch.cuda.get_device_name(current_gpu_index)
    # 获取GPU显存的总量和已使用量
    total_memory = torch.cuda.get_device_properties(current_gpu_index).total_memory / (1024 ** 3)  # 显存总量(GB)
    used_memory = torch.cuda.memory_allocated(current_gpu_index) / (1024 ** 3)  # 已使用显存(GB)
    free_memory = total_memory - used_memory  # 剩余显存(GB)
    print(f"CUDA可用，共有 {num_gpu} 个GPU设备可用。")
    print(f"当前使用的GPU设备索引：{current_gpu_index}")
    print(f"当前使用的GPU设备名称：{current_gpu_name}")
    print(f"GPU显存总量：{total_memory:.2f} GB")
    print(f"已使用的GPU显存：{used_memory:.2f} GB")
    print(f"剩余GPU显存：{free_memory:.2f} GB")
else:
    print("CUDA不可用。")
# 检查PyTorch版本
print(f"PyTorch版本：{torch.__version__}")
import torch
print(f"CUDA版本：{torch.version.cuda}")
```


windows先装显卡驱动，再装CUDA10.2，最后装了pytorch。

pip install torch==1.10.1+cu102 torchvision==0.13.1+cu102 torchaudio==0.12.1 --extra-index-url https://download.pytorch.org/whl/cu102


![在这里插入图片描述](/static/img/images/03938.png)



```python
import torch
import os
import subprocess

def check_gpu_availability():
    print("==== Checking GPU Availability ====")
    if torch.cuda.is_available():
        print(f"GPU is available. Number of GPUs: {torch.cuda.device_count()}")
        for i in range(torch.cuda.device_count()):
            print(f"GPU {i}: {torch.cuda.get_device_name(i)}")
    else:
        print("No GPU available. Please check your hardware or drivers.")
        return False
    return True

def check_cuda_and_cudnn():
    print("\n==== Checking CUDA and cuDNN Availability ====")
    if torch.cuda.is_available():
        print(f"CUDA version: {torch.version.cuda}")
        print(f"cuDNN version: {torch.backends.cudnn.version()}")
        print(f"cuDNN enabled: {torch.backends.cudnn.enabled}")
    else:
        print("CUDA or cuDNN not available. Please check the installation.")

def test_gpu_computation():
    print("\n==== Testing Simple Computation on GPU ====")
    try:
        
        device = torch.device("cuda:2")
        a = torch.randn(50, 50, device=device)
        b = torch.randn(50, 50, device=device)
        c = torch.matmul(a, b)
        print("Matrix multiplication on GPU successful.")
    except Exception as e:
        print(f"Error during computation on GPU: {e}")

def check_gpu_memory():
    print("\n==== Checking GPU Memory Usage ====")
    try:
        gpu_memory = torch.cuda.memory_summary()
        print(gpu_memory)
    except Exception as e:
        print(f"Error retrieving GPU memory info: {e}")

def run_nvidia_smi():
    print("\n==== Running nvidia-smi Command ====")
    try:
        # Run the nvidia-smi command and capture the output
        result = subprocess.run(["nvidia-smi"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
        if result.returncode == 0:
            print(result.stdout)
        else:
            print(f"Error running nvidia-smi: {result.stderr}")
    except Exception as e:
        print(f"Error running nvidia-smi command: {e}")

def main():
    print("==== Starting GPU Health Check ====")
    
    # Step 1: Check GPU availability
    if not check_gpu_availability():
        return
    
    # Step 2: Check CUDA and cuDNN versions
    check_cuda_and_cudnn()
    
    # Step 3: Test GPU computation
    test_gpu_computation()
    
    # Step 4: Check GPU memory usage
    check_gpu_memory()
    
    # Step 5: Run nvidia-smi to check GPU status
    run_nvidia_smi()
    
    print("\n==== GPU Health Check Completed ====")

if __name__ == "__main__":
    main()

```

【Python】pytorch，CUDA是否可用，查看显卡显存剩余容量

# conda





```c
conda config --set ssl_verify no
conda config --set proxy_servers.http <VPN 服务器地址>:<VPN 服务器端口>
conda config --set proxy_servers.https <VPN 服务器地址>:<VPN 服务器端口>
```


```c
conda install <package_name>
```


# pip

```c
pip --proxy <VPN 服务器地址>:<VPN 服务器端口> install requests
```

example.


```c
 pip install --proxy http://127.0.0.1:10809 -r req.txt
```

给conda、pip提提速，给他一个vpn，还世界清静

# 环境





```shell
pip install jupyter 
```

# 使用

在你想访问的目录下执行：


```c
jupyter notebook --ip=0.0.0.0
```

jupyter 给出提示：

```c
[I 2023-07-28 14:32:43.589 ServerApp] Package notebook took 0.0000s to import
[I 2023-07-28 14:32:43.597 ServerApp] Package jupyter_lsp took 0.0081s to import
[W 2023-07-28 14:32:43.597 ServerApp] A `_jupyter_server_extension_points` function was not found in jupyter_lsp. Instead, a `_jupyter_server_extension_paths` function was found and will be used for now. This function name will be deprecated in future releases of Jupyter Server.
[I 2023-07-28 14:32:43.601 ServerApp] Package jupyter_server_terminals took 0.0034s to import
[I 2023-07-28 14:32:43.601 ServerApp] Package jupyterlab took 0.0000s to import
[I 2023-07-28 14:32:43.639 ServerApp] Package notebook_shim took 0.0000s to import
[W 2023-07-28 14:32:43.640 ServerApp] A `_jupyter_server_extension_points` function was not found in notebook_shim. Instead, a `_jupyter_server_extension_paths` function was found and will be used for now. This function name will be deprecated in future releases of Jupyter Server.
[I 2023-07-28 14:32:43.640 ServerApp] jupyter_lsp | extension was successfully linked.
[I 2023-07-28 14:32:43.643 ServerApp] jupyter_server_terminals | extension was successfully linked.
[I 2023-07-28 14:32:43.647 ServerApp] jupyterlab | extension was successfully linked.
[I 2023-07-28 14:32:43.651 ServerApp] notebook | extension was successfully linked.
[I 2023-07-28 14:32:43.654 ServerApp] Writing Jupyter server cookie secret to /home/xd/.local/share/jupyter/runtime/jupyter_cookie_secret
[I 2023-07-28 14:32:43.827 ServerApp] notebook_shim | extension was successfully linked.
[I 2023-07-28 14:32:43.930 ServerApp] notebook_shim | extension was successfully loaded.
[I 2023-07-28 14:32:43.932 ServerApp] jupyter_lsp | extension was successfully loaded.
[I 2023-07-28 14:32:43.933 ServerApp] jupyter_server_terminals | extension was successfully loaded.
[I 2023-07-28 14:32:43.934 LabApp] JupyterLab extension loaded from /ssd/xd/miniconda3/envs/py38_diffusers_1/lib/python3.8/site-packages/jupyterlab
[I 2023-07-28 14:32:43.934 LabApp] JupyterLab application directory is /ssd/xd/miniconda3/envs/py38_diffusers_1/share/jupyter/lab
[I 2023-07-28 14:32:43.935 LabApp] Extension Manager is 'pypi'.
[I 2023-07-28 14:32:43.937 ServerApp] jupyterlab | extension was successfully loaded.
[I 2023-07-28 14:32:43.939 ServerApp] notebook | extension was successfully loaded.
[I 2023-07-28 14:32:43.939 ServerApp] Serving notebooks from local directory: /ssd/xd/workplace
[I 2023-07-28 14:32:43.939 ServerApp] Jupyter Server 2.7.0 is running at:
[I 2023-07-28 14:32:43.939 ServerApp] http://gpu20:8888/tree?token=490e738359e9e3a73247822c61620bacdfcae0038a9a721e
[I 2023-07-28 14:32:43.939 ServerApp]     http://127.0.0.1:8888/tree?token=490e738359e9e3a73247822c61620bacdfcae0038a9a721e
[I 2023-07-28 14:32:43.939 ServerApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[W 2023-07-28 14:32:43.948 ServerApp] No web browser found: Error('could not locate runnable browser').
```


记住这提示里的token：

490e738359e9e3a73247822c61620bacdfcae0038a9a721e

# 访问

windows电脑浏览器访问：

http://101.20.31.20:8888


默认端口8888，前面的ip需要填写你Linux服务器的IP。

【Python】jupyter Linux服务器使用

基础环境：





```c
sudo apt-get install ffmpeg
```


# m4a


要将M4A文件转换为MP3文件，你可以使用Python中的第三方库`pydub`。`pydub`使得音频处理变得非常简单。在开始之前，请确保你已经安装了`pydub`库，如果没有，可以通过以下命令安装：

```bash
pip install pydub
```

接下来，你可以使用以下代码将M4A文件转换为MP3文件：

```python
from pydub import AudioSegment
def m4a_to_mp3(m4a_file, mp3_file):
    # Load the M4A file
    audio = AudioSegment.from_file(m4a_file, format="m4a")
    # Export the audio as MP3
    audio.export(mp3_file, format="mp3")
if __name__ == "__main__":
    input_m4a_file = "input_file.m4a"   # Replace with the path to your M4A file
    output_mp3_file = "output_file.mp3" # Replace with the desired output MP3 file path
    m4a_to_mp3(input_m4a_file, output_mp3_file)
```

将上述代码中的`input_m4a_file`替换为你要转换的M4A文件路径，`output_mp3_file`替换为你希望输出的MP3文件路径。然后运行代码，它将加载M4A文件并将其转换为MP3格式。请注意，转换过程可能需要一些时间，具体取决于文件大小和你的计算机性能。

提醒：在进行音频格式的转换时，请遵守相关版权法规和使用规定，确保你有权处理和使用这些文件。




# aac

要将AAC文件转换为MP3文件，你可以使用Python中的`pydub`库，它提供了一个简单的方法来进行音频格式转换。在开始之前，请确保已经安装了`pydub`库，如果没有，可以通过以下命令安装：

```bash
pip install pydub
```

接下来，你可以使用以下代码将AAC文件转换为MP3文件：

```python
from pydub import AudioSegment
def aac_to_mp3(aac_file, mp3_file):
    # Load the AAC file
    audio = AudioSegment.from_file(aac_file, format="aac")
    # Export the audio as MP3
    audio.export(mp3_file, format="mp3")
if __name__ == "__main__":
    input_aac_file = "input_file.aac"   # Replace with the path to your AAC file
    output_mp3_file = "output_file.mp3" # Replace with the desired output MP3 file path
    aac_to_mp3(input_aac_file, output_mp3_file)
```

将上述代码中的`input_aac_file`替换为你要转换的AAC文件路径，`output_mp3_file`替换为你希望输出的MP3文件路径。然后运行代码，它将加载AAC文件并将其转换为MP3格式。请注意，转换过程可能需要一些时间，具体取决于文件大小和你的计算机性能。

同样地，在进行音频格式的转换时，请确保你有权处理和使用这些文件，遵守相关版权法规和使用规定。

【Python】将M4A\AAC录音文件转换为MP3文件

Python代码：




```powershell
import os
def split_file(input_file, output_dir, chunk_size):
    with open(input_file, 'rb') as f:
        index = 0
        while True:
            chunk = f.read(chunk_size)
            if not chunk:
                break
            output_file = os.path.join(output_dir, f'chunk_{index}.dat')
            with open(output_file, 'wb') as out:
                out.write(chunk)
            index += 1
def merge_files(input_dir, output_file):
    files = os.listdir(input_dir)
    files.sort()
    with open(output_file, 'wb') as out:
        for file_name in files:
            file_path = os.path.join(input_dir, file_name)
            with open(file_path, 'rb') as f:
                chunk = f.read()
                out.write(chunk)
# 切分大文件
split_file('big_file.dat', 'output_dir', 10 * 1024 * 1024)  # 每个小文件大小为10GB
# 合并小文件
merge_files('output_dir', 'merged_file.dat')
```

【Python】大文件切分为小文件，小文件组合为大文件

# 概括





注意，在哪个平台运行打包，就会对应生成那个平台的可执行文件。比如我在windows中执行，我将会得到exe执行包。

使用PyInstaller打包Python代码成为可执行的exe文件非常简单。以下是基本的步骤：

**1、确保你已经安装了PyInstaller。如果没有安装，可以通过以下命令来安装：**

```powershell
pip install pyinstaller
```


**2、打开终端或命令提示符，并导航到你的Python代码所在的目录。**

**3、在终端或命令提示符中运行以下命令：**

```powershell
pyinstaller -F your_script.py
```

其中，your_script.py 是你要打包的Python脚本的文件名。

**4、PyInstaller将会自动分析你的脚本，并创建一个与你的脚本同名的文件夹。**

**5、在生成的文件夹中，你可能会看到一些额外的文件，例如.spec文件和一个名为dist的文件夹。**

**6、最终的可执行文件可以在dist文件夹中找到，文件名通常与你的脚本的文件名相同。**

现在，你就可以将生成的可执行文件(.exe)拷贝到其他机器上，并在不安装Python解释器的情况下运行你的代码了。


常用指令：

```powershell
Pyinstaller -F setup.py # 打包exe
Pyinstaller -F -w setup.py # 不带控制台的打包
Pyinstaller -F -i xx.ico setup.py # 打包指定exe图标打包
```

# 混合打包

参考：

https://blog.csdn.net/tangfreeze/article/details/112240342

https://pyinstaller.org/en/stable/spec-files.html#adding-files-to-the-bundle

我想将一些资源文件也打包进exe如何办？

运行：

```powershell
pyinstaller -F -w -i 2.ico  --add-data  ".\1.ico;."  setup.py
```

-i 图标路径

–icon=图标路径

-F 打包成一个exe文件

-w 使用窗口，无控制台

-c 使用控制台，无窗口

-D 创建一个目录，里面包含exe以及其他一些依赖性文件


# 重要！

完成打包后，setup.exe里面如果依赖了外部文件，应该注意python找文件的写法：

![在这里插入图片描述](/static/img/images/04384.png)

比如：

```python
import sys
import tkinter as tk
from os import path
from tkinter import ttk
import serial
import threading
# 先获取当前运行时临时目录路径
if getattr(sys, 'frozen', None):
    basedir = sys._MEIPASS
else:
    basedir = path.dirname(__file__)
ico_file = path.join(basedir, '1.ico')
```

【python】如何使用pyinstaller打包python代码成为可执行的exe，依赖文件加入

# 最终效果





![在这里插入图片描述](/static/img/images/04385.png)

# python环境

```powershell
pip install pyserial 
```

#  部分代码

```python
import tkinter as tk
from tkinter import ttk
import serial
import threading
class info_window:
    def __init__(self, in_str, parent):
        self.parent = parent  # 保存父窗口对象
        self.window = tk.Toplevel(parent)
        self.window.title("提示")
        self.window.iconbitmap('1.ico')
        self.window.geometry("220x60")
        label = tk.Label(self.window, text=in_str)
        buttonOK = tk.Button(self.window, text="OK", command=self.button_ok)
        label.pack(side=tk.TOP)
        buttonOK.pack(side=tk.BOTTOM)
        # 移动到parent屏幕中央
        self.window.update()
        x = self.parent.winfo_x() + (self.parent.winfo_width() - self.window.winfo_reqwidth()) / 2
        y = self.parent.winfo_y() + (self.parent.winfo_height() - self.window.winfo_reqheight()) / 2
        self.window.geometry("+%d+%d" % (x, y))
    def button_ok(self):
        self.window.destroy()
class main_gui:
    def __init__(self):
        self.window = tk.Tk()
        self.window.title("代做QQ742971636")
        self.window.iconbitmap('1.ico')
        self.uartState = False  # is uart open or not
        self.is_running = True
        # 帧布：1
        config_frame = tk.Frame(self.window)
        config_frame.grid(row=1, column=1)
        label_com = tk.Label(config_frame, text="COMx: ")
        self.COM = tk.StringVar(value="COM4")
        ertryCOM = tk.Entry(config_frame, textvariable=self.COM)
        label_com.grid(row=1, column=1, padx=5, pady=3)
        ertryCOM.grid(row=1, column=2, padx=5, pady=3)
        label_baudrate = tk.Label(config_frame, text="波特率: ")
        self.Baudrate = tk.IntVar(value=9600)
        ertryBaudrate = tk.Entry(config_frame, textvariable=self.Baudrate)
        label_baudrate.grid(row=1, column=3, padx=5, pady=3)
        ertryBaudrate.grid(row=1, column=4, padx=5, pady=3)
        labelParity = tk.Label(config_frame, text="校验位: ")
        self.Parity = tk.StringVar(value="NONE")
        comboParity = ttk.Combobox(config_frame, width=17, textvariable=self.Parity)
        comboParity["values"] = ("NONE", "ODD", "EVEN", "MARK", "SPACE")
        comboParity["state"] = "readonly"
        labelParity.grid(row=2, column=1, padx=5, pady=3)
        comboParity.grid(row=2, column=2, padx=5, pady=3)
        labelStopbits = tk.Label(config_frame, text="停止位: ")
        self.Stopbits = tk.StringVar(value="1")
        comboStopbits = ttk.Combobox(config_frame, width=17, textvariable=self.Stopbits)
        comboStopbits["values"] = ("1", "1.5", "2")
        comboStopbits["state"] = "readonly"
        labelStopbits.grid(row=2, column=3, padx=5, pady=3)
        comboStopbits.grid(row=2, column=4, padx=5, pady=3)
        labelDatabits = tk.Label(config_frame, text="数据位: ")
        self.Databits = tk.StringVar(value="8")
        comboDatabits = ttk.Combobox(config_frame, width=17, textvariable=self.Databits)
        comboDatabits["values"] = ("8", "7", "6", "5")
        comboDatabits["state"] = "readonly"
        labelDatabits.grid(row=3, column=1, padx=5, pady=3)
        comboDatabits.grid(row=3, column=2, padx=5, pady=3)
        # 帧布：2
        frame_open_serial = tk.Frame(self.window)
        frame_open_serial.grid(row=2, column=1)
        self.buttonSS = tk.Button(frame_open_serial, text="打开串口", command=self.open_serial)
        self.buttonSS.pack(side=tk.BOTTOM)
        # serial object
        self.ser = serial.Serial()
        self.read_data_from_serialThread = threading.Thread(target=self.read_data_from_serial)
        self.read_data_from_serialThread.start()
        # 帧布：3
        rev_frame = tk.Frame(self.window)
        rev_frame.grid(row=3, column=1)
        labelOutText = tk.Label(rev_frame, text="接收数据:")
        labelOutText.grid(row=1, column=1, padx=3, pady=2, sticky=tk.W)
        rev_frameSon = tk.Frame(rev_frame)
        rev_frameSon.grid(row=2, column=1)
        scrollbarRecv = tk.Scrollbar(rev_frameSon)
        scrollbarRecv.pack(side=tk.RIGHT, fill=tk.Y)
        self.OutputText = tk.Text(rev_frameSon, wrap=tk.WORD, width=60, height=20, yscrollcommand=scrollbarRecv.set)
        self.OutputText.pack()
        # 帧布：4
        clear_frame = tk.Frame(self.window)
        clear_frame.grid(row=4, column=1)
        self.buttonClear = tk.Button(clear_frame, text="清空", command=self.clear_received_data)
        self.buttonClear.pack(side=tk.BOTTOM)
        # 帧布：5
        transfer_frame = tk.Frame(self.window)
        transfer_frame.grid(row=5, column=1)
        labelInText = tk.Label(transfer_frame, text="发送数据:")
        labelInText.grid(row=1, column=1, padx=3, pady=2, sticky=tk.W)
        transfer_frameSon = tk.Frame(transfer_frame)
        transfer_frameSon.grid(row=2, column=1)
        scrollbarTrans = tk.Scrollbar(transfer_frameSon)
        scrollbarTrans.pack(side=tk.RIGHT, fill=tk.Y)
        self.InputText = tk.Text(transfer_frameSon, wrap=tk.WORD, width=60, height=5, yscrollcommand=scrollbarTrans.set)
        self.InputText.insert(tk.END, "qq742971636代码测试\r\n")
        self.InputText.pack()
        # 帧布：6
        send_frame = tk.Frame(self.window)
        send_frame.grid(row=6, column=1)
        self.buttonSend = tk.Button(send_frame, text="发送", command=self.send_data_to_serial)
        self.buttonSend.pack(side=tk.BOTTOM)
        self.window.protocol("WM_DELETE_WINDOW", self.on_closing)
        self.window.mainloop()
    def clear_received_data(self):
        self.OutputText.delete('1.0', tk.END)
    def open_serial(self):
        if self.uartState:
            self.ser.close()
            self.buttonSS["text"] = "打开串口"
            self.uartState = False
        else:
            # restart serial port
            self.ser.port = self.COM.get()
            self.ser.baudrate = self.Baudrate.get()
            strParity = self.Parity.get()
            if strParity == "NONE":
                self.ser.parity = serial.PARITY_NONE
            elif strParity == "ODD":
                self.ser.parity = serial.PARITY_ODD
            elif strParity == "EVEN":
                self.ser.parity = serial.PARITY_EVEN
            elif strParity == "MARK":
                self.ser.parity = serial.PARITY_MARK
            elif strParity == "SPACE":
                self.ser.parity = serial.PARITY_SPACE
            strStopbits = self.Stopbits.get()
            if strStopbits == "1":
                self.ser.stopbits = serial.STOPBITS_ONE
            elif strStopbits == "1.5":
                self.ser.stopbits = serial.STOPBITS_ONE_POINT_FIVE
            elif strStopbits == "2":
                self.ser.stopbits = serial.STOPBITS_TWO
            # 数据位8位
            strDatabits = self.Databits.get()
            if strDatabits == "8":
                self.ser.bytesize = serial.EIGHTBITS
            elif strDatabits == "7":
                self.ser.bytesize = serial.SEVENBITS
            elif strDatabits == "6":
                self.ser.bytesize = serial.SIXBITS
            elif strDatabits == "5":
                self.ser.bytesize = serial.FIVEBITS
            try:
                self.ser.open()
            except:
                infromStr = "不能打开串口 " + self.ser.port
                info_window(infromStr, self.window)
            if self.ser.isOpen():  # open success
                self.buttonSS["text"] = "关闭串口"
                self.uartState = True
## 实验报告：串口通信图形用户界面设计与实现
### 背景
本实验旨在设计和实现一个基于Python的图形用户界面（GUI），用于通过串口进行数据传输和接收。该界面允许用户配置串口参数，如端口号、波特率、校验位、停止位和数据位，并实现数据的发送与接收。串口通信在嵌入式系统、物联网设备以及工业控制等领域中广泛应用，能够实现不同设备之间的可靠通信。
### 器件与工具
1. 计算机
2. Python 3.x
3. Tkinter库（用于GUI开发）
4. PySerial库（用于串口通信）
5. 串口设备（如开发板、传感器等）
### 硬件连接
1. 将计算机通过USB连接到串口设备。
2. 确认串口设备的端口号（如COM4）。
3. 根据设备的规格设置合适的波特率、校验位、停止位和数据位。
### 设计原理
本实验通过Tkinter库创建一个图形用户界面，用户可以在界面中配置串口参数并进行数据的发送和接收。PySerial库用于实现串口通信。界面包括以下功能模块：
1. 串口配置模块：用户可以选择端口号、波特率、校验位、停止位和数据位。
2. 串口控制模块：打开和关闭串口。
3. 数据接收模块：显示接收到的数据。
4. 数据发送模块：用户输入要发送的数据并发送到串口。
### 电路原理
电路连接较为简单，计算机通过USB接口与串口设备相连。串口设备的TX（发送）引脚连接到计算机的RX（接收）引脚，RX引脚连接到计算机的TX引脚，GND引脚连接到计算机的GND引脚。
### 程序原理
程序使用Tkinter库创建主窗口和各个子窗口，使用PySerial库实现串口的打开、关闭、读写操作。程序包括以下几个主要部分：
#### 串口配置
串口配置部分通过创建文本框和下拉菜单，供用户输入和选择端口号、波特率、校验位、停止位和数据位。以下代码片段展示了如何创建这些配置选项：
```python

config_frame = tk.Frame(self.window)

config_frame.grid(row=1, column=1)

label_com = tk.Label(config_frame, text="COMx: ")

self.COM = tk.StringVar(value="COM4")

ertryCOM = tk.Entry(config_frame, textvariable=self.COM)

label_com.grid(row=1, column=1, padx=5, pady=3)

ertryCOM.grid(row=1, column=2, padx=5, pady=3)

label_baudrate = tk.Label(config_frame, text="波特率: ")

self.Baudrate = tk.IntVar(value=9600)

ertryBaudrate = tk.Entry(config_frame, textvariable=self.Baudrate)

label_baudrate.grid(row=1, column=3, padx=5, pady=3)

ertryBaudrate.grid(row=1, column=4, padx=5, pady=3)
```
#### 串口控制
串口控制部分包括打开和关闭串口的功能，通过点击按钮触发相应的事件。以下代码展示了如何实现串口的打开和关闭：
```python

def open_serial(self):

    if self.uartState:

        self.ser.close()

        self.buttonSS["text"] = "打开串口"

        self.uartState = False

    else:

        self.ser.port = self.COM.get()

        self.ser.baudrate = self.Baudrate.get()

        self.ser.open()

        if self.ser.isOpen():

            self.buttonSS["text"] = "关闭串口"

            self.uartState = True
```
#### 数据接收与显示
数据接收部分通过创建一个线程不断读取串口数据，并将数据显示在文本框中：
```python

self.read_data_from_serialThread = threading.Thread(target=self.read_data_from_serial)

self.read_data_from_serialThread.start()

def read_data_from_serial(self):

    while self.is_running:

        if self.ser.isOpen():

            data = self.ser.read_all()

            if data:

                self.OutputText.insert(tk.END, data.decode('utf-8'))

                self.OutputText.see(tk.END)
```
#### 数据发送
数据发送部分允许用户在文本框中输入要发送的数据，并通过点击按钮发送数据到串口：
```python

def send_data_to_serial(self):

    if self.ser.isOpen():

        data = self.InputText.get("1.0", tk.END).strip()

        self.ser.write(data.encode('utf-8'))
```

### 实验结果

通过上述设计和实现，成功开发了一个功能完整的串口通信图形用户界面。用户可以方便地配置串口参数，打开和关闭串口，发送和接收数据。该界面运行稳定，能够满足基本的串口通信需求。

### 结论

本实验通过使用Tkinter和PySerial库，实现了一个简单但功能强大的串口通信图形用户界面。该界面为用户提供了友好的操作方式，便于进行串口通信的配置和数据传输。未来可以在此基础上扩展更多功能，如增加日志记录、数据分析等。

### 参考文献

- Python官方文档

- Tkinter库使用手册

- PySerial库使用手册


资源

https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2

【python】基于TK Tkinter pyserial 串口调试助手，支持中英文编码

在C++中将cv::Mat保存为文件，然后在Python中加载为NumPy数组，可以使用OpenCV和NumPy库来完成。以下是一个示例代码，展示了如何执行这些步骤：





C++ 代码（使用OpenCV保存图像）：

```python
#include <opencv2/opencv.hpp>
int main()
{
    cv::Mat outimg;  // 假设你已经创建了名为 outimg 的 cv::Mat 对象
    // 保存为文件
    cv::FileStorage fs("outimg.yml", cv::FileStorage::WRITE);
    fs << "outimg" << outimg;
    fs.release();
    return 0;
}
```

Python 代码（使用NumPy加载数据）：

```python
import numpy as np
import cv2
# 加载数据
fs = cv2.FileStorage("outimg.yml", cv2.FILE_STORAGE_READ)
outimg = fs.getNode("outimg").mat()
fs.release()
# 将数据转换为 NumPy 数组
outimg_np = np.array(outimg)
# 打印数组
print(outimg_np)
```

这段代码将保存名为 "outimg.yml" 的文件，然后使用 Python 读取该文件并将其转换为 NumPy 数组。你可以根据需要修改文件名和路径。确保在 C++ 程序中创建的 cv::Mat 对象命名为 outimg，以便与 Python 中的节点名称相匹配。

如何在C++中把cv::Mat outimg（元素全部是0到1之间的浮点数）存为一个文件，然后使用python打开成numpy数据

opencv中的模糊方法使用




```python
import cv2
import numpy as np
def Gaussian(image):
    # 进行高斯模糊
    ksize = (11, 11)  # 模糊核的大小
    sigmaX = 5  # X方向的标准差，设为0表示从ksize计算
    image = cv2.GaussianBlur(image, ksize, sigmaX)
    image = cv2.GaussianBlur(image, ksize, sigmaX)
    return image
def blur(image):
    # 进行均值模糊
    ksize = (11, 11)  # 模糊核的大小
    image = cv2.blur(image, ksize)
    image = cv2.blur(image, ksize)
    return image
def medianBlur(image):
    # 进行中值模糊
    ksize = 11  # 模糊核的大小
    image = cv2.medianBlur(image, ksize)
    image = cv2.medianBlur(image, ksize)
    return image
def bilateralFilter(image):
    # 进行双边滤波
    d = 15  # 领域直径
    sigmaColor = 75  # 色彩空间的标准差
    sigmaSpace = 75  # 坐标空间的标准差
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    return image
def medianBlur(image):
    # 进行双边滤波
    d = 15  # 领域直径
    sigmaColor = 75  # 色彩空间的标准差
    sigmaSpace = 75  # 坐标空间的标准差
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    return image
def filter2D(image):
    # 自定义模糊核
    kernel = np.ones((5, 5), dtype=np.float32) / 25  # 5x5的均匀权重的模糊核
    # 进行自定义模糊
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    return image
# 读取图像
image = cv2.imread('image.jpg')
image = filter2D(image)
# 显示模糊后的图像
cv2.imshow('Gaussian Blur', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
```