python实现振动传感器串口通信（没有可视化界面版）（可运行代码）

武德呢武德呢

已于 2025-03-23 20:55:41 修改

阅读量167

点赞数 2

文章标签： python 振动传感器串口通信

于 2025-03-23 20:38:41 首次发布

本文链接：https://blog.csdn.net/qq_54650942/article/details/146461525

版权

用python实现振动传感器的串口通信。

举个测加速度的例子，这是我的振动传感器。

只测一次加速度数据

import serial
import time

# 配置串口参数
serial_port = 'COM8'  # 根据你的实际情况修改串口名称
baud_rate = 9600      # 根据你的传感器波特率配置
timeout = 1           # 设置读取超时时间（秒）

try:
    # 打开串口
    ser = serial.Serial(serial_port, baud_rate, timeout=timeout)
    print(f"串口 {serial_port} 已打开，波特率：{baud_rate}")

    hex_str = bytes.fromhex('50 03 00 34 00 03 49 84')  # 你要传给振动传感器的数据
    ser.write(hex_str)
    time.sleep(0.1)  # 等待传感器响应

    # 读取串口数据
    if ser.in_waiting > 0:
        data = ser.read(ser.in_waiting)  # 读取所有可用数据

        print(f"接收到的数据: {data.hex()}")  # 以十六进制显示数据

        AXH = data[3]  # 第4个十六进制数字符串
        AXL = data[4]  # 第5个十六进制数字符串
        AYH = data[5]  # 第6个十六进制数字符串
        AYL = data[6]  # 第7个十六进制数字符串
        AZH = data[7]  # 第8个十六进制数字符串
        AZL = data[8]  # 第9个十六进制数字符串

        # 将AXH和AXL组合成一个16位的整数
        AX = (AXH << 8) | AXL
        AY = (AYH << 8) | AYL
        AZ = (AZH << 8) | AZL

        # 缩放因子，根据传感器数据手册指定
        SCALE_FACTOR = 32768.0

        # 重力加速度，单位为m/s^2
        G = 9.8  # 通常取9.81，但这里为了简化取9.8

        ACCELERATION_X = (AX / SCALE_FACTOR) * 16 * G
        ACCELERATION_Y = (AY / SCALE_FACTOR) * 16 * G
        ACCELERATION_Z = (AZ / SCALE_FACTOR) * 16 * G

        # 输出加速度X的值
        print(f"加速度X的值为: {ACCELERATION_X:.2f} m/s^2")
        print(f"加速度Y的值为: {ACCELERATION_Y:.2f} m/s^2")
        print(f"加速度Z的值为: {ACCELERATION_Z:.2f} m/s^2")

    # 延迟以避免过于频繁地读取
    time.sleep(0.1)

except serial.SerialException as e:
    print(f"串口错误: {e}")
except KeyboardInterrupt:
    print("程序被用户中断")
finally:
    if 'ser' in locals() and ser.is_open:
        ser.close()
        print("串口已关闭")

运行结果

循环测加速度数据

import serial
import time

# 配置串口参数
serial_port = 'COM8'  # 根据你的实际情况修改串口名称
baud_rate = 9600      # 根据你的传感器波特率配置
timeout = 1           # 设置读取超时时间（秒）

try:
    # 打开串口
    ser = serial.Serial(serial_port, baud_rate, timeout=timeout)
    print(f"串口 {serial_port} 已打开，波特率：{baud_rate}")

    while True:
        hex_str = bytes.fromhex('50 03 00 34 00 03 49 84')  # 你要传给振动传感器的数据
        ser.write(hex_str)
        time.sleep(0.1)  # 等待传感器响应
        
        # 读取串口数据
        if ser.in_waiting > 0:
            data = ser.read(ser.in_waiting)  # 读取所有可用数据
            print(f"接收到的数据: {data.hex()}")  # 以十六进制显示数据

            AXH = data[3]  # 第4个十六进制数字符串
            AXL = data[4]  # 第5个十六进制数字符串
            AYH = data[5]  # 第6个十六进制数字符串
            AYL = data[6]  # 第7个十六进制数字符串
            AZH = data[7]  # 第8个十六进制数字符串
            AZL = data[8]  # 第9个十六进制数字符串

            # 将AXH和AXL组合成一个16位的整数
            AX = (AXH << 8) | AXL
            AY = (AYH << 8) | AYL
            AZ = (AZH << 8) | AZL

            # 缩放因子，根据传感器数据手册指定
            SCALE_FACTOR = 32768.0

            # 重力加速度，单位为m/s^2
            G = 9.8  # 通常取9.81，但这里为了简化取9.8

            ACCELERATION_X = (AX / SCALE_FACTOR) * 16 * G
            ACCELERATION_Y = (AY / SCALE_FACTOR) * 16 * G
            ACCELERATION_Z = (AZ / SCALE_FACTOR) * 16 * G

            # 输出加速度X的值
            print(f"加速度X的值为: {ACCELERATION_X:.2f} m/s^2")
            print(f"加速度Y的值为: {ACCELERATION_Y:.2f} m/s^2")
            print(f"加速度Z的值为: {ACCELERATION_Z:.2f} m/s^2")

        # 延迟以避免过于频繁地读取
        time.sleep(1)

except serial.SerialException as e:
    print(f"串口错误: {e}")
except KeyboardInterrupt:
    print("程序被用户中断")
finally:
    if 'ser' in locals() and ser.is_open:
        ser.close()
        print("串口已关闭")

运行结果

循环测多种数据

import serial
import time

# 加速度 振动速度 振动位移
# 配置串口参数
serial_port = 'COM8'  # 根据你的实际情况修改串口名称
baud_rate = 9600      # 根据你的传感器波特率配置
timeout = 1           # 设置读取超时时间（秒）


def func1():  # 加速度
    hex_str = bytes.fromhex('50 03 00 34 00 03 49 84')  # 你要传给振动传感器的数据
    ser.write(hex_str)
    time.sleep(0.1)  # 等待传感器响应

    # 读取串口数据
    if ser.in_waiting > 0:
        data = ser.read(ser.in_waiting)  # 读取所有可用数据
        print(f"接收到的数据: {data.hex()}")  # 以十六进制显示数据

        AXH = data[3]  # 第4个十六进制数字符串
        AXL = data[4]  # 第5个十六进制数字符串
        AYH = data[5]  # 第6个十六进制数字符串
        AYL = data[6]  # 第7个十六进制数字符串
        AZH = data[7]  # 第8个十六进制数字符串
        AZL = data[8]  # 第9个十六进制数字符串

        # 将AXH和AXL组合成一个16位的整数
        AX = (AXH << 8) | AXL
        AY = (AYH << 8) | AYL
        AZ = (AZH << 8) | AZL

        # 缩放因子，根据传感器数据手册指定
        SCALE_FACTOR = 32768.0

        # 重力加速度，单位为m/s^2
        G = 9.8  # 通常取9.81，但这里为了简化取9.8

        ACCELERATION_X = (AX / SCALE_FACTOR) * 16 * G
        ACCELERATION_Y = (AY / SCALE_FACTOR) * 16 * G
        ACCELERATION_Z = (AZ / SCALE_FACTOR) * 16 * G

        # 输出加速度X的值
        print(f"加速度X的值为: {ACCELERATION_X:.2f} m/s^2")
        print(f"加速度Y的值为: {ACCELERATION_Y:.2f} m/s^2")
        print(f"加速度Z的值为: {ACCELERATION_Z:.2f} m/s^2")

    # 延迟以避免过于频繁地读取
    time.sleep(0.1)


def func2():  # 振动速度
    hex_str = bytes.fromhex('50 03 00 3A 00 03 28 47')  # 你要传给振动传感器的数据
    ser.write(hex_str)
    time.sleep(0.1)  # 等待传感器响应

    # 读取串口数据
    if ser.in_waiting > 0:
        data = ser.read(ser.in_waiting)  # 读取所有可用数据
        print(f"接收到的数据: {data.hex()}")  # 以十六进制显示数据

        VXH = data[3]  # 第4个十六进制数字符串
        VXL = data[4]  # 第5个十六进制数字符串
        VYH = data[5]  # 第6个十六进制数字符串
        VYL = data[6]  # 第7个十六进制数字符串
        VZH = data[7]  # 第8个十六进制数字符串
        VZL = data[8]  # 第9个十六进制数字符串

        # 将AXH和AXL组合成一个16位的整数
        VX = (VXH << 8) | VXL
        VY = (VYH << 8) | VYL
        VZ = (VZH << 8) | VZL

        # 输出加速度X的值
        print(f"振动速度VX的值为: {VX:.2f} mm/S")
        print(f"振动速度VY的值为: {VY:.2f} mm/S")
        print(f"振动速度VZ的值为: {VZ:.2f} mm/S")

    # 延迟以避免过于频繁地读取
    time.sleep(0.1)


def func3():  # 振动位移
    hex_str = bytes.fromhex('50 03 00 41 00 03 58 5E')  # 你要传给振动传感器的数据
    ser.write(hex_str)
    time.sleep(0.1)  # 等待传感器响应

    # 读取串口数据
    if ser.in_waiting > 0:
        data = ser.read(ser.in_waiting)  # 读取所有可用数据
        print(f"接收到的数据: {data.hex()}")  # 以十六进制显示数据

        DXH = data[3]  # 第4个十六进制数字符串
        DXL = data[4]  # 第5个十六进制数字符串
        DYH = data[5]  # 第6个十六进制数字符串
        DYL = data[6]  # 第7个十六进制数字符串
        DZH = data[7]  # 第8个十六进制数字符串
        DZL = data[8]  # 第9个十六进制数字符串

        # 将AXH和AXL组合成一个16位的整数
        DX = (DXH << 8) | DXL
        DY = (DYH << 8) | DYL
        DZ = (DZH << 8) | DZL

        # 输出加速度X的值
        print(f"振动位移DX的值为: {DX:.2f} um")
        print(f"振动位移DY的值为: {DY:.2f} um")
        print(f"振动位移DZ的值为: {DZ:.2f} um")

    # 延迟以避免过于频繁地读取
    time.sleep(0.1)


try:
    # 打开串口
    ser = serial.Serial(serial_port, baud_rate, timeout=timeout)
    print(f"串口 {serial_port} 已打开，波特率：{baud_rate}")

    while True:
        func1()
        func2()
        func3()
        print("---------------------------------------------------------------")
        time.sleep(0.5)

except serial.SerialException as e:
    print(f"串口错误: {e}")
except KeyboardInterrupt:
    print("程序被用户中断")
finally:
    if 'ser' in locals() and ser.is_open:
        ser.close()
        print("串口已关闭")

运行结果