用Python采用Modbus-Tcp的方式读取485电子水尺数据

原创 已于 2024-01-25 15:51:34 修改 · 2.4k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #tcp/ip #网络 #物联网

于 2023-07-14 15:15:47 首次发布

README.TXT

2023/6/15 
V1.0 实现了单个点位数据通信、数据解析、数据存储
2023/6/17
V2.0 实现了多个点位数据通信、数据解析、数据存储
2023/6/19
V2.1 完善log存储，仅保留近3天的log记录，避免不必要的存储；限制log大小，2MB。

架构介绍

使用Python开发服务器程序，实现以下功能：

  1. 采用问询的方式读取各类传感器数据
  2. 正确高速解析各类传感器的数据
  3. 存储解析后的各类传感器数据
  4. 存储程序运行过程中的log
  5. 管理log，超过一定量、一定时间自动删除log
  6. 打包发布 或者 在后台运行py服务器程序

硬件介绍 传感器 串口服务器 采集模块 5G通信模块

主要传感器

485电子水尺传感器

该传感器支持485通信

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

其他硬件：

485漏液侦测传感器
485采集模块
串口服务器
5G通信模块

调试工具

采集模块调试工具

在这里插入图片描述

485电子水尺调试工具

在这里插入图片描述

串口调试助手，主要用于 漏液传感器在这里插入图片描述

其他工具

CRC计算器，不过我一般都是自己写CRC校验程序，CRC校验程序放在后面完整代码了

在这里插入图片描述

WIN10自带的计算器

在这里插入图片描述

调试过程

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

完整代码 LOG存储功能、数据读取解析存储功能

#!D:/workplace/python
# -*- coding: utf-8 -*-
# @File  : main0620.py
# @Author:Romulushe
# @Time    : 2023/6/20 13:53
# @Software: PyCharm
# @Use: PyCharm
import os
import sys
import logging
import time
from logging.handlers import RotatingFileHandler
import shutil
import socket
import threading
import pymysql
import binascii
import time
import datetime

base_path = os.path.dirname(os.path.realpath(sys.argv[0]))


def get_log_path():
    return os.path.join(base_path, 'logs')


def cleanup_logs():
    log_path = get_log_path()
    current_time = time.time()
    for file_name in os.listdir(log_path):
        file_path = os.path.join(log_path, file_name)
        if os.path.isfile(file_path):
            creation_time = os.path.getctime(file_path)
            if current_time - creation_time > (3 * 24 * 60 * 60):
                os.remove(file_path)


def configure_logging():
    log_path = get_log_path()
    os.makedirs(log_path, exist_ok=True)
    log_filename = get_log_filename()
    log_file = os.path.join(log_path, log_filename)
    logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s', filename=log_file)


def get_log_filename():
    now = datetime.datetime.now()
    return now.strftime("%Y-%m-%d_%H-%M.log")


def create_new_log():
    log_path = get_log_path()
    log_files = os.listdir(log_path)
    if len(log_files) >= 20:
        oldest_file = min(log_files)
        os.remove(os.path.join(log_path, oldest_file))
    log_filename = get_log_filename()
    log_filepath = os.path.join(log_path, log_filename)
    return log_filepath


def check_log_size(log_filepath):
    log_size = os.path.getsize(log_filepath)
    if log_size > 2 * 1024 * 1024:
        # 创建新的日志文件
        new_log_filepath = create_new_log()
        try:
            shutil.move(log_filepath, new_log_filepath)
            return new_log_filepath
        except PermissionError:
            insert_log(logger, f'{log_filepath} {PermissionError}', log_filepath)
            time.sleep(0.1)
            return log_filepath
    return log_filepath

def insert_log(logger, log_message, log_filepath):
    log_filepath = check_log_size(log_filepath)

    # 创建文件处理器
    file_handler = RotatingFileHandler(log_filepath, maxBytes=2 * 1024 * 1024, backupCount=1)
    file_handler.setLevel(logging.DEBUG)
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(formatter)

    # 添加文件处理器到日志记录器
    logger.addHandler(file_handler)

    try:
        logger.debug(log_message)
    except PermissionError:
        insert_log(logger, f'{log_message} {PermissionError}', log_filepath)
        time.sleep(0.1)  # 延迟0.1秒

    # 移除文件处理器
    logger.removeHandler(file_handler)


# 定义个函数，使其专门重复处理客户端的请求数据（也就是重复接受一个用户的消息并且重复回答，直到用户选择下线）
def client_request_1(tcp_client_1, tcp_client_address):
    #print(tcp_client_1)

    # 循环接收和发送数据
    while True:
        # #print(datetime.datetime.today())
        # msg=["010300000005859C","02020000000879FF"]
        # msg=['010300010001D5CA',"02020000000879FF"]
        # msg=["010300000001840A","02020000000879FF"]#8点位
        msg=msg_address(tcp_client_address)
        # interval =60
        interval = int(60 / len(msg))
        # print(interval,type(interval))
        for i in msg:
            try:
                tcp_client_1.send(binascii.unhexlify(i))
                recv_data = tcp_client_1.recv(4096)
                # 有消息就回复数据，消息长度为0就是说明客户端下线了
                if recv_data:
                    # #print(f"recv_data:{recv_data}")
                    bistr = binascii.hexlify(recv_data).decode('utf8')
                    # print("==================================================")
                    # print(f"读数：【{bistr}】,{len(bistr)}")
                    try:
                        if (bistr.startswith('010302') or bistr.startswith('030302') ) and len(bistr) >=14:
                            bistr=bistr[:15]
                            # # 输入数据
                            input_data = bistr[:-4]
                            # # 计算带有校验码的结果
                            result = calculate_checksum(input_data)
                            if bistr == result:
                                waterLevel = int(bistr[6:10], 16)
                                print("水深", waterLevel, "cm", bistr, bistr[6:10], bistr[:-4], bistr[-4:], "input_data:",
                                      {input_data}, " result:", {result})
                                # #print(bistr==result)
                                ip_address(tcp_client_address[0], tcp_client_address[1], waterLevel, 'water')
                        if bistr.startswith("020201") and len(bistr) >= 12:
                            bistr = bistr[:13]
                            # 输入数据
                            input_data = bistr[:-4]
                            # 计算带有校验码的结果
                            result = calculate_checksum(input_data)
                            # #print(result==bistr)
                            if result == bistr:
                                data = data_address(bistr)
                                #print(f"水泵采集模块状态:{data}")
                                ip_address(tcp_client_address[0], tcp_client_address[1], data, 'status')
                                ip_address(tcp_client_address[0], tcp_client_address[1], data, 'fault')
                        if bistr.startswith("0104") and len(bistr) >= 14:
                            bistr = bistr[:15]
                            # 输入数据
                            input_data = bistr[:-4]
                            # # 计算带有校验码的结果
                            result = calculate_checksum(input_data)
                            if result == bistr:
                                # #print(f"bistr[6:10]:{bistr[6:10]}")
                                data =int(bistr[6:10], 16)
                                #print(f"漏液检测状态:{data}")
                                ip_address(tcp_client_address[0], tcp_client_address[1], data, 'liquid')
                    except Exception as e:
                        insert_log(logger, f'{tcp_client_address} {e}', log_filepath)
                        #print(e)
                else:
                    #print("%s 客户端下线了..." % tcp_client_address[1])
                    insert_log(logger, f'{tcp_client_address[1]} OFFLINE', log_filepath)
                    tcp_client_1.close()
                    break
                # time.sleep(interval)
                time.sleep(2)
            except Exception as e:
                insert_log(logger, f'{tcp_client_address} {i} {e}', log_filepath)
                #print(f"{tcp_client_address} {i} {e}")


# 连接数据库
def connect_database(host, port, user, password, db_name):
    try:
        conn = pymysql.connect(host=host, port=port, user=user, password=password, db=db_name)
        # print("成功连接到数据库")
        return conn
    except pymysql.Error as e:
        insert_log(logger, f'DATABASE CONNECT FAILED', log_filepath)
        # print(f"数据库连接失败: {e}")

# 插入数据
def insert_data(conn, types,table_name, create_time, location_no, parameter_desc, location, param_value):
    try:
        cursor = conn.cursor()
        sql = f"INSERT INTO {table_name} (TYPE, CREATE_TIME, LOCATION_NO, PARAMETER_DESC, LOCATION, PARAMVALUE) " \
              f"VALUES (%s, %s, %s, %s, %s, %s)"
        cursor.execute(sql, (types,create_time, location_no, parameter_desc, location, param_value))
        conn.commit()
        # print(f"数据插入成功: {create_time}, {parameter_desc}: {param_value}")
        cursor.close()
    except pymysql.Error as e:
        insert_log(logger, f'DATABASE INSERT DATA FAILED', log_filepath)
        # print(f"数据插入失败: {e}")



def msg_address(tcp_client_address):
    if tcp_client_address[0] == '根据实际IP修改' or tcp_client_address[0] == '根据实际IP修改' or tcp_client_address[0] == '根据实际IP修改' :
        msg = ["010300000001840A", "02020000000879FF"]  # 8点位无其他，水位01,状态02
        return msg
    if (tcp_client_address[0] == '根据实际IP修改' and tcp_client_address[1] == 10010 )or tcp_client_address[0] == '根据实际IP修改' or (tcp_client_address[0] == '根据实际IP修改'  and tcp_client_address[1] == 10000 ) or tcp_client_address[0] == '根据实际IP修改'  or tcp_client_address[0] == '根据实际IP修改' :
        msg =["010300000001840A", "02020000000879FF"]  # 4点位非漏液，水位01,状态02
        return msg
    if (tcp_client_address[0] =='根据实际IP修改'  and tcp_client_address[1] == 10000 )or (tcp_client_address[0] == '根据实际IP修改'  and tcp_client_address[1] == 10010):
        msg = ["01040000000131CA"]  # 4点位漏液
        return msg
    if tcp_client_address[0] == '根据实际IP修改' :
        msg = ["010300010001D5CA","01040000000131CA"]  # 2点位漏液,漏液01,水位02
        return msg
    if tcp_client_address[0] == '根据实际IP修改' :
        msg = ["03030000000185E8","02020000000879FF"]  # 展厅漏液01,水位03，状态02
        # msg = ["03030000000185E8", "02020000000879FF", "01040000000131CA"]  # 展厅漏液01,水位03，状态02
        return msg

#ip判断
def ip_address(ip,port,param_value,notes):
    host = ''#根据实际情况自定义
    port = 3306
    user =''#根据实际情况自定义
    password = ''#根据实际情况自定义
    db_name = ''#根据实际情况自定义
    table_name =''#根据实际情况自定义
    # 连接数据库
    conn = connect_database(host, port, user, password, db_name)

    #8点位采集+水尺
    if str(ip)==''#根据实际情况自定义:
        #只有1号端口
        #水位尺数据
        #采集模块数据
        # 数据库连接信息
        types = '防汛'
        create_time = datetime.datetime.now()
        location = ''#根据实际情况自定义
        # 模拟数据
        if notes=='water':
           location_no =''#根据实际情况自定义
            parameter_desc = '水位值'
            # 插入数据
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

        if notes=='status':
            data=param_value
            # print("data:",data)
            status1=data[0]#1
            status2=data[1]#2
            status3=data[4]#5
            status4=data[6]#7
            # print("status1,status2,status3,status4:",status1,status2,status3,status4)
            # # 插入1号数据
            location_no = 'D04-01'
            parameter_desc = '1号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status1)
            # 插入2号数据
            location_no = 'D04-02'
            parameter_desc = '2号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status2)
            # 插入3号数据
            location_no = 'D04-03'
            parameter_desc = '3号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status3)
            # 插入4号数据
            location_no = 'D04-04'
            parameter_desc = '4号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status4)

        if notes=='fault':
            data = param_value
            fault1 = data[2]#3
            fault2 = data[3]#4
            fault3 = data[5]#6
            fault4 = data[7]#8
            # print("fault1,fault2,fault3,fault4:",fault1,fault2,fault3,fault4)

            # 插入1号数据
            location_no = 'D04-05'
            parameter_desc = '1号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault1)
            # 插入2号数据
            location_no = 'D04-06'
            parameter_desc = '2号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault2)
            # 插入3号数据
            location_no = 'D04-07'
            parameter_desc = '3号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault3)
            # 插入4号数据
            location_no = 'D04-08'
            parameter_desc = '4号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault4)
    # 8点位采集+水尺
    if str(ip)==''#根据实际情况自定义:
        #只有1号端口
        #水位尺数据
        #采集模块数据
        # 数据库连接信息
        types = '防汛'
        create_time = datetime.datetime.now()
        location =''#根据实际情况自定义

        # 模拟数据
        if notes=='water':
            location_no = 'D07'
            parameter_desc = '水位值'
            # 插入数据
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

        if notes=='status':
            data=param_value
            status1=data[0]
            status2=data[1]
            status3=data[2]
            status4=data[3]
            #print("status1,status2,status3,status4:",status1,status2,status3,status4)
            # 插入1号数据
            location_no = 'D07-01'
            parameter_desc = '1号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status1)
            # 插入2号数据
            location_no = 'D07-02'
            parameter_desc = '2号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status2)
            # 插入3号数据
            location_no = 'D07-03'
            parameter_desc = '3号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status3)
            # 插入4号数据
            location_no = 'D07-04'
            parameter_desc = '4号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status4)

        if notes=='fault':
            data=param_value

            fault1 = data[4]
            fault2 = data[5]
            fault3 = data[6]
            fault4 = data[7]
            #print("fault1,fault2,fault3,fault4:",fault1,fault2,fault3,fault4)

            # 插入1号数据
            location_no = 'D07-05'
            parameter_desc = '1号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault1)
            # 插入2号数据
            location_no = 'D07-06'
            parameter_desc = '2号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault2)
            # 插入3号数据
            location_no = 'D07-07'
            parameter_desc = '3号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault3)
            # 插入4号数据
            location_no = 'D07-08'
            parameter_desc = '4号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault4)
    # 8点位采集+水尺
    if str(ip) == ''#根据实际情况自定义:
        # 只有1号端口
        # 水位尺数据
        # 采集模块数据
        # 数据库连接信息
        types = '防汛'
        create_time = datetime.datetime.now()
        location = ''#根据实际情况自定义
        # 模拟数据
        if notes == 'water':
            location_no = 'D08'
            parameter_desc = '水位值'
            # 插入数据
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

        if notes == 'status':
            data=param_value
            status1 = data[0]
            status2 = data[1]
            status3 = data[2]
            status4 = data[3]
            #print("status1,status2,status3,status4:", status1, status2, status3, status4)
            # 插入1号数据
            location_no = 'D08-01'
            parameter_desc = '1号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status1)
            # 插入2号数据
            location_no = 'D08-02'
            parameter_desc = '2号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status2)
            # 插入3号数据
            location_no = 'D08-03'
            parameter_desc = '3号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status3)
            # 插入4号数据
            location_no = 'D08-04'
            parameter_desc = '4号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status4)

        if notes == 'fault':
            data=param_value

            fault1 = data[4]
            fault2 = data[5]
            fault3 = data[6]
            fault4 = data[7]
            #print("fault1,fault2,fault3,fault4:", fault1, fault2, fault3, fault4)

            # 插入1号数据
            location_no = 'D08-05'
            parameter_desc = '1号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault1)
            # 插入2号数据
            location_no = 'D08-06'
            parameter_desc = '2号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault2)
            # 插入3号数据
            location_no = 'D08-07'
            parameter_desc = '3号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault3)
            # 插入4号数据
            location_no = 'D08-08'
            parameter_desc = '4号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault4)

    # 4点位采集+水尺
    if str(ip) ==''#根据实际情况自定义:
        # 只有1号端口
        # 水位尺数据
        # 采集模块数据
        # 数据库连接信息
        types = '防汛'
        create_time = datetime.datetime.now()
        location = ''#根据实际情况自定义
        # 模拟数据
        if notes == 'water':
            location_no = 'D09'
            parameter_desc = '水位值'
            # 插入数据
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

        if notes == 'status':
            data=param_value
            status1 = data[0]
            status2 = data[1]
            #print("status1,status2:", status1, status2)
            # 插入1号数据
            location_no = 'D09-01'
            parameter_desc = '1号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status1)
            # 插入2号数据
            location_no = 'D09-02'
            parameter_desc = '2号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status2)

        if notes == 'fault':
            data=param_value
            fault1 = data[2]
            fault2 = data[3]
            #print("fault1,fault2:", fault1, fault2)

            # 插入1号数据
            location_no = 'D09-03'
            parameter_desc = '1号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault1)
            # 插入2号数据
            location_no = 'D09-04'
            parameter_desc = '2号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault2)
        if notes == 'liquid':
            data_liquid = param_value
            # 插入漏液数据
            location_no = 'F03'
            parameter_desc = ''#根据实际情况自定义
            location=''#根据实际情况自定义
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, data_liquid)

    # 4点位采集+水尺
    if str(ip) ==''#根据实际情况自定义:
        # 只有1号端口
        # 水位尺数据
        # 采集模块数据
        # 数据库连接信息
        types = '防汛'
        create_time = datetime.datetime.now()
        location =''#根据实际情况自定义
        # 模拟数据
        if notes == 'water':
            location_no = 'D06'
            parameter_desc = '水位值'
            # 插入数据
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

        if notes == 'status':
            data=param_value
            status1 = data[0]
            status2 = data[1]
            #print("status1,status2:", status1, status2)
            # 插入1号数据
            location_no = 'D06-01'
            parameter_desc = '1号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status1)
            # 插入2号数据
            location_no = 'D06-02'
            parameter_desc = '2号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status2)

        if notes == 'fault':
            data=param_value
            fault1 = data[2]
            fault2 = data[3]
            #print("fault1,fault2:", fault1, fault2)

            # 插入1号数据
            location_no = 'D06-03'
            parameter_desc = '1号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault1)
            # 插入2号数据
            location_no = 'D06-04'
            parameter_desc = '2号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault2)

    # 4点位采集+水尺
    if str(ip) ==''#根据实际情况自定义:
        # 只有1号端口
        # 水位尺数据
        # 采集模块数据
        # 数据库连接信息
        types = '防汛'
        create_time = datetime.datetime.now()
        location = ''#根据实际情况自定义
        # 模拟数据
        if notes == 'water':
            location_no = 'D05'
            parameter_desc = '水位值'
            # 插入数据
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

        if notes == 'status':
            data=param_value
            status1 = data[0]
            status2 = data[1]
            # 插入1号数据
            location_no = 'D05-01'
            parameter_desc = '1号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status1)
            # 插入2号数据
            location_no = 'D05-02'
            parameter_desc = '2号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status2)

        if notes == 'fault':
            data=param_value
            fault1 = data[2]
            fault2 = data[3]

            # 插入1号数据
            location_no = 'D05-03'
            parameter_desc = '1号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault1)
            # 插入2号数据
            location_no = 'D05-04'
            parameter_desc = '2号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault2)

        if notes == 'liquid':
            data_liquid = param_value
            # 插入漏液数据
            location_no = 'F02'
            parameter_desc =''#根据实际情况自定义
            location=''#根据实际情况自定义
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, data_liquid)

    # 4点位采集+水尺
    if str(ip) == ''#根据实际情况自定义:
        # 只有1号端口
        # 水位尺数据
        # 采集模块数据
        # 数据库连接信息
        types = '防汛'
        create_time = datetime.datetime.now()
        location = ''#根据实际情况自定义
        # 模拟数据
        if notes == 'water':
            location_no = 'D03'
            parameter_desc = '水位值'
            # 插入数据
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

        if notes == 'status':
            data=param_value
            status1 = data[0]
            status2 = data[1]
            #print("status1,status2:", status1, status2)
            # 插入1号数据
            location_no = 'D03-01'
            parameter_desc = '1号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status1)
            # 插入2号数据
            location_no = 'D03-02'
            parameter_desc = '2号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status2)

        if notes == 'fault':
            data=param_value
            fault1 = data[2]
            fault2 = data[3]
            #print("fault1,fault2:", fault1, fault2)

            # 插入1号数据
            location_no = 'D03-03'
            parameter_desc = '1号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault1)
            # 插入2号数据
            location_no = 'D03-04'
            parameter_desc = '2号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault2)

    # 4点位采集+水尺
    if str(ip) == ''#根据实际情况自定义:
        # 只有1号端口
        # 水位尺数据
        # 采集模块数据
        # 数据库连接信息
        types = '防汛'
        create_time = datetime.datetime.now()
        location =''#根据实际情况自定义
        # 模拟数据
        if notes == 'water':
            location_no = 'D01'
            parameter_desc = '水位值'
            # 插入数据
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

        if notes == 'status':
            data=param_value
            status1 = data[0]
            status2 = data[1]
            #print("status1,status2:", status1, status2)
            # 插入1号数据
            location_no = 'D01-01'
            parameter_desc = '1号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status1)
            # 插入2号数据
            location_no = 'D01-02'
            parameter_desc = '2号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status2)

        if notes == 'fault':
            data=param_value
            fault1 = data[2]
            fault2 = data[3]
            #print("fault1,fault2:", fault1, fault2)

            # 插入1号数据
            location_no = 'D01-03'
            parameter_desc = '1号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault1)
            # 插入2号数据
            location_no = 'D01-04'
            parameter_desc = '2号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault2)

    # 4点位采集+水尺
    if str(ip) == ''#根据实际情况自定义:
        # 只有1号端口
        # 水位尺数据
        # 采集模块数据
        # 数据库连接信息
        types = '防汛'
        create_time = datetime.datetime.now()
        location =''#根据实际情况自定义
        # 模拟数据
        if notes == 'water':
            location_no = 'D02'
            parameter_desc = '水位值'
            print( 'water:',param_value)
            # 插入数据
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

        if notes == 'status':
            data=param_value
            status1 = data[0]
            status2 = data[1]
            print("status1,status2:", status1, status2)
            # 插入1号数据
            location_no = 'D02-01'
            parameter_desc = '1号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status1)
            # 插入2号数据
            location_no = 'D02-02'
            parameter_desc = '2号泵浦状态'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, status2)

        if notes == 'fault':
            data=param_value
            fault1 = data[2]
            fault2 = data[3]
            print("fault1,fault2:", fault1, fault2)

            # 插入1号数据
            location_no = 'D02-03'
            parameter_desc = '1号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault1)
            # 插入2号数据
            location_no = 'D02-04'
            parameter_desc = '2号泵浦故障'
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, fault2)

        if notes == 'liquid':
            data_liquid = param_value
            print('liquid:'.data_liquid)
            # 插入漏液数据
            location_no = 'F01'
            parameter_desc =''#根据实际情况自定义
            location=''#根据实际情况自定义
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, data_liquid)

    # 2点位采集+水尺
    if str(ip) == ''#根据实际情况自定义:
        # 只有1号端口
        # 水位尺数据
        # 采集模块数据
        # 数据库连接信息
        types = '防汛'
        create_time = datetime.datetime.now()
        # 模拟数据
        if notes == 'water':
            location_no = 'D10'
            parameter_desc = '水位值'
            location =''#根据实际情况自定义
            # 插入数据
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

        if notes == 'liquid':
            data_liquid = param_value
            # 插入漏液数据
            location_no = 'F04'
            parameter_desc = ''#根据实际情况自定义
            location = ''#根据实际情况自定义
            insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, data_liquid)

def data_address(data):
    extracted_data = data[6:8]
    binary_data = bin(int(extracted_data, 16))[2:].zfill(8)
    reversed_data = binary_data[::-1]
    return reversed_data

#CRC校验
def calculate_crc(data):
    crc = 0xFFFF
    polynomial = 0xA001

    for byte in data:
        crc ^= byte
        for _ in range(8):
            if crc & 0x0001:
                crc >>= 1
                crc ^= polynomial
            else:
                crc >>= 1

    return crc

def calculate_checksum(data):
    # 将输入数据转换为字节列表
    data_bytes = bytes.fromhex(data)

    # 计算校验码
    crc_value = calculate_crc(data_bytes)
    crc_bytes = crc_value.to_bytes(2, 'big')  # 将校验码转换为2字节的大端字节序
    checksum = ''.join(format(byte, '02x') for byte in reversed(crc_bytes))  # 转换为十六进制字符串，并反转字节顺序

    # 将校验码插入到原数据之后
    result = data + checksum
    return result



if __name__ == '__main__':
    configure_logging()
    cleanup_logs()

    log_filepath = create_new_log()

    logger = logging.getLogger()
    logger.setLevel(logging.DEBUG)

    oldtime = datetime.datetime.today()
    # 创建服务端套接字对象
    tcp_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置端口复用，使程序退出后端口马上释放
    tcp_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    # 绑定端口
    tcp_server.bind(("", 8050))
    # 设置监听
    tcp_server.listen(128)
    # 循环等待客户端连接请求

   while True:
        tcp_client_1, tcp_client_address = tcp_server.accept()
        tcp_client_1.settimeout(10)
        # 创建多线程对象
        thd = threading.Thread(target=client_request_1, args=(tcp_client_1, tcp_client_address))
        # #print(thd)
        # 设置守护主线程
        thd.setDaemon(True)
        # 启动子线程对象
        thd.start()
        # 关闭服务器套接字
        # tcp_server.close()`
delphi tclientsocket接收不到返回数据_RS—485中教你主站发送报文结构、从站返回报文结构？系列11...
weixin_39997443的博客
11-27 740
作者：马乐1.主站发送报文结构大家可以看到我之前写的文章中的程序都是没有什么具体功能的，都是两个站点之间互相传递数据，这些数据我们只是看看是否可以正常接收发送，数据本身是没有任何含义的。很明显在实际使用过程中我们是不会这样去用的，对于通讯来说主站发送的数据通常只有两个功能，一是读取从站寄存器中地址的状态也就是从从站读取数据，二是向从站写入数据。那么主站要怎么发送数据从站才能知道，主站是要读数据还是...
树莓派485转USB串口调试教程
beiye_的博客
05-26 6270
关于树莓派485转USB与PC端进行串口通讯教程
PLC-Recorder通过Modbus TCP/Modbus RTU转换器实现RS-485总线设备采集的方法
chengjl8的博客
04-01 3666
PLC-Recorder是一款基于以太网的高速数据采集软件，用于故障诊断、工艺过程数据连续记录等。对于现场大量存在的通过RS-485进行通讯的Modbus RTU设备，该如何采集呢？可以通过Modubs RTU到Modbus TCP的协议转换器来进行采集。 目前，国内这类协议转换器的品牌很多，价格已经很低，基本在500元以下了，只要进行一些简单配置，就可以实现众多Modbus RTU设备的数据采集。 一般来说，一个协议转换器可以通过RS-485总线同时与多个从站通讯，因此，TCP侧就需要知道从站的站点地
Python 与 RS-485 传感器设备进行串口通信, 读取数值
热门推荐
Y_xianlin的博客
07-10 1万+
使用Python与RS-485传感器设备, 进行串口通信; 将RS - 485传感器设备先转成RS-232, 然后将RS -232转成USB串口, 插入到串口, 即可使用电脑COM进行串口通信与485设备进行通信
基于Python的ModbusTCP客户端实现
weixin_34252090的博客
02-22 1197
Modbus协议是由Modicon公司（现在的施耐德电气Schneider Electric）推出，主要建立在物理串口、以太网TCP/IP层之上，目前已经成为工业领域通信协议的业界标准，广泛应用在工业电子设备之间的互联。Modbus Poll和Modbus Slave是两款非常流行的Modbus设备仿真软件，支持Modbus RTU/ASCII和Modbus TCP/IP协议 ，经常用于测试和调试...
电子-一种水柱式电子水尺
09-15
这些资料对于设备的使用者、维护技术人员、销售推广人员乃至监管机构而言都是极其宝贵的信息来源，它们不仅帮助相关人员深入了解和掌握电子水尺的使用方法，还确保了设备的正确安装、有效维护以及安全可靠的运行。...
SSCK.WC-1型触点式电子水尺(RS485)使用说明书2015.3.20.doc
10-12
SSCK.WC-1型触点式电子水尺(RS485)使用说明书2015.3.20.doc
网络管理-信息化-T港水尺检验信息化管理的研究.pdf
07-09
在中国经济的迅猛发展和对外贸易不断演变的背景下，传统的重量鉴定方式正面临着前所未有的挑战。借助计算机技术的普及与应用，自动化鉴定业务得以迅速发展，对提升检验业务效率产生了显著的推动作用。尽管如此，各...
行业分类-物理装置-一种柔性电子水尺及采用该水尺测流速的方法.zip
09-09
行业分类-物理装置-一种柔性电子水尺及采用该水尺测流速的方法
电子-一种电子水尺
09-15
标题中的“电子水尺”是一种基于电子技术的设备，用于测量液位，特别是在水体中的高度。这种设备通常采用传感器技术，例如电容式、超声波或压力感应器，来检测水面与传感器之间的距离，并将这个信息转换为电信号，...
测试程序_树莓派python采集485设备数据_
10-02
通过CBT-1009
stm32f103 通过485方式读取数据
01-11
stm32f103通过使用RS485方式读取盐度，PH，温度等水体数据并打印到显示屏上进行实时显示
用Python写的Modbus-TCP/IP客户端
08-06
用Python写的Modbus-TCP/IP客户端，可用，文档虽小，但功能能实现，请需要的朋友下载，更改后就可以是自己的了
利用python获取modbus tcp数据
weixin_35749786的博客
02-11 1214
要利用 Python 获取 Modbus TCP 数据，您可以使用第三方库如 pymodbus。您可以通过以下步骤操作： 安装 pymodbus：运行 pip install pymodbus。 导入 pymodbus 库：在 Python 代码中导入 import modbus_tk.modbus_tcp as modbus_tcp。 创建 Modbus TCP 客户端：使用 client =...
python读取RS485接口的TH10S-B温度传感器数据
java_raylu的博客
07-07 5889
准备TH10S-B温度sensor一个准备RS485 USB转换器一个 连线，插到电脑USB口，设置端口：可以用商家的软件测试下传感器是否正常：进入正题，解析RS485数据首先安装serial包，使用serials.Serial()时我遇到个错误报错module 'serial' has no attribute 'Serial'解决办法，卸载serial，重新安装pyserial 正式代码如下： 安装完运行结果：TH10S-B厂商手册对返回收据解析说明如下：实际上我看不懂这个手册。哈哈问了商家，
用Python采用Modbus-Tcp的方式读取PLC模块数据
the_beginner的博客
07-13 4220
【代码】用Python采用Modbus-Tcp的方式读取PLC模块数据。
python 实现Modebus 通信（pyModbusTCP ）
姚家湾博客
06-28 7463
尽管python 并不实现实时控制应用程序，但是它编写程序实在是太方便了。至少在程序快速成型和验证过程中可以使用Python 来实现，另一方面，Python 强大的数值计算和图形显示能力也能够实现modbus 设备的远程监控，数据采集，甚至AI 训练。注意的是 auto_open和auto_close两个标记，它指明每次请求modbusTCP 时是否会自动打开和关闭TCP/IP 连接。如果auto_close=True 表示每次都会自动关闭连接，经测试，它会引起2秒中的延时。
Python---Modbus RS-485 串口通信
weixin_57999977的博客
09-25 6065
python进行modbus通信的简要方式
【python读取485串口数据并转存到MySQL数据库】
qq_31717259的博客
06-30 2652
python读取485串口数据并转存到MySQL数据库。 1、读485数据； 2、16进制数据转换为10进制数据； 3、连接MySQL数据库更新数据； 4、循环判断数据准确性，获取到正确数据后循环主程序。
使用tcp协议时每次读取的设备的数据count不一致为什么
最新发布
10-25
<think>首先，用户的问题是：“我想查找使用TCP协议时每次读取设备数据count不一致的原因 请问使用TCP协议读取设备数据时每次读取数据count不一致的原因”。关键是理解“count不一致”的意思：在TCP通信中，读取数据时返回的字节数（count）可能每次不同。 从引用中提取关键信息： - 引用[1]：TCP协议发送数据到发送缓冲区，由内核控制发送决策。这暗示了TCP流控和缓冲机制可能导致数据读取量不确定。 - 引用[2]：Java TCP通信中，客户端和服务端有输入输出流；读取时无法预知有多少字节属于文件名或内容，强调TCP字节流的连续性。 - 引用[3]：描述Modbus通信中的count参数，表示读取连续地址的数量，影响数据读写。 - 引用[4]：Timeout参数用于Modbus超时控制。 - 引用[5]：Python使用Modbus-Tcp读取数据。 用户的问题是通用TCP协议读取数据时count不一致的原因，不是特定于Modbus。但引用提到Modbus，可能用户场景涉及设备通信如Modbus-TCP。 核心原因：TCP是面向流的协议（stream-oriented），而不是面向消息的（message-oriented）。这意味着数据被划分为字节流，没有内置的消息边界。发送方发送的数据可能被分割成多个段（segments）传输，接收方读取时可能一次读取部分数据或在缓冲区累积数据后读取更多。 所以，原因包括： 1. **网络条件**：网络延迟、拥塞可能导致数据包分段传输或重传，影响接收方读取的字节数。 2. **系统缓冲区大小**：TCP接收缓冲区的大小和状态；如果缓冲区满，可能只读取部分数据。 3. **读取操作**：应用程序调用read或recv时，指定缓冲区大小；实际读取的字节数取决于内核缓冲区中可用数据的多少。 4. **协议设计**：TCP不保证每次读取返回固定大小的块；它提供字节流，应用程序需要处理消息边界。 用户提到“count不一致”，可能指在类似Modbus的应用中读取数据时count参数返回的数据量变化。在引用[3]中，count用于指定读取的地址数量，但TCP读取操作本身可能返回可变字节数。 在编程层面，原因如下： - **套接字API行为**：当调用read/recv时，它返回实际读取的字节数，可能小于请求的缓冲区大小。 - **滑动窗口和流量控制**：TCP的流量控制机制可能导致发送方暂停发送，从而接收方读取较少数据。 - **延迟确认和数据累计**：接收方可能延迟发送ACK，导致发送方发送更多数据在单个包中。 在设备通信上下文（如Modbus-TCP），Modbus协议定义消息帧结构，包括头部和数据字段。但TCP传输可能导致消息被拆分或合并在多个读取操作中。 总结主要原因： - **TCP流性质**：数据是连续的字节流；没有固定的消息边界。 - **接收缓冲区状态**：内核缓冲区中数据的可用性。 - **应用程序逻辑**：读取函数的行为；例如，在Java或Python中，InputStream.read或socket.recv返回实际读取的字节数。 - **网络抖动**：传输过程中数据包丢失或延迟导致部分数据到达。 回答结构： - 解释TCP协议的本质特征。 - 分析具体原因。 - 给出解决方案建议。 - 生成相关问题。 使用中文回答，结构清晰。 参考用户上一次问题：用户可能之前讨论过TCP或Modbus通信问题；但基于上下文，用户直接问了这个新问题，所以专注于此。 生成相关问题：在末尾添加相关的问题。 确保回答真实可靠：基于TCP协议标准和常见编程实践。 最终回答大纲： 1. 介绍TCP协议的基本特性：面向流的协议。 2. 解释为什么读取count可能不一致：网络缓冲、系统调用等。 3. 具体原因列表。 4. 如何解决：使用消息边界、缓冲区管理等。 5. 相关问题。 </think>### 使用TCP协议读取设备数据时count不一致的原因分析 在使用TCP协议读取设备数据时，“count不一致”指每次调用读取函数（如recv、read或类似API）返回的实际字节数（count）可能不同。这源于TCP协议的固有机制和底层系统行为，并非设备或程序错误。以下我将逐步解释原因，基于TCP协议原理和相关引用内容。 #### 1. **TCP协议的基本特性导致的根本原因** - **面向流的传输机制**: TCP是一种面向流的协议（stream-oriented），而不是面向消息的协议（message-oriented）。它将数据视为连续的字节流，不保证每次读取返回固定大小的数据块。发送方写入TCP发送缓冲区的数据，可能被内核分割成多个段（segments）传输；接收方读取时，内核根据接收缓冲区的实际可用数据量返回相应字节数。这可能导致count值变化[^1]。 - 例如，在引用[1]中提到：“TCP协议发送数据, 是将数据拷贝到发送缓冲区, 然后由内核中的TCP协议自行决策”，这说明发送和接收决策由内核控制，应用程序无法预知每次读取的确切字节数。 - **网络条件和流量控制**: TCP内置流量控制机制（滑动窗口）和拥塞控制。如果网络拥塞或接收方处理速度慢，发送方会减少数据发送速率，导致接收缓冲区数据不足；反之，网络稳定时缓冲区可能累积更多数据，读取count增大。 #### 2. **具体导致count不一致的常见原因** - **接收缓冲区状态波动**: - 接收方的内核缓冲区（receive buffer）数据量动态变化。如果读取时缓冲区为空或仅有部分数据，count值可能较小（例如仅返回几个字节）；如果缓冲区累积了多个数据包，count值可能较大（接近应用程序请求的buffer大小）。 - 在设备通信场景（如Modbus-TCP），引用[3]中提到count参数用于指定读取的地址数量，但TCP层实际返回的字节数取决于缓冲区状态，而非count参数定义的数量。 - **数据分段和重组延迟**: - 发送方发送的数据可能被分成多个IP包传输。接收方TCP层需要重组这些包才能交付应用层。如果某些包延迟或丢失（需重传），读取操作可能只返回完整数据的一部分，导致count减少。 - **读取操作的异步性**: - 应用程序调用读取函数（如`socket.recv()`或`InputStream.read()`）时，指定一个缓冲区大小，但实际返回的字节数是即时可用的数据量。这受系统调度、CPU负载影响。 - 引用[2]强调了该问题：“单从流本身来看是无法知道从流中读取多少字节是文件名,多少字节是文件内容”，说明TCP字节流无法自动划分消息边界，count值自然不稳定。 - **超时和错误处理影响**: - 如果设置超时（Timeout），如引用[4]所述：“若达到设定值后，还未获得从站的响应，则PLC认为从站出问题”，可能导致读取提前中断，返回部分数据（count值变小）。 - 错误（如网络中断）会触发故障代码（引用[3]中的Error字段），但即使无错误，常规操作也可能因缓冲区空而返回count=0。 - **协议应用层逻辑问题**: - 在Modbus-TCP等协议中，count参数定义请求的数据量（如地址数量），但TCP传输可能导致响应数据被拆分。例如，引用[3]描述读取多个地址时数据存储到VB102和VW104，但TCP读取可能分多次完成，每次count不同。 #### 3. **如何解决或缓解count不一致问题** - **使用消息边界机制**: 在应用层添加消息边界，例如： - 定义消息头（header）包含数据长度（length字段），接收方先读取长度信息，再读取指定字节数。 - 在Java或Python中，可用定界符（如特殊字符）标识消息结束。 - **循环读取和缓冲区管理**: - 循环调用读取函数，直到累积足够数据或接收EOF信号。例如在Python中： ```python data = b'' while len(data) < expected_length: # expected_length为预期数据大小 chunk = sock.recv(buffer_size) if not chunk: break data += chunk ``` - 引用[5]的Python实现可能采用类似方式处理多个点位的通信和数据存储。 - **调整缓冲区大小和超时设置**: - 设置较大的接收缓冲区（通过setsockopt），减少频繁部分读取。 - 优化超时值（引用[4]），避免因短时延迟导致的读取中断。 - **协议特定优化**: 在Modbus-TCP中，确保请求count值合理，避免过大请求导致数据拆分；同时检查Done位（引用[3]）实现轮询，处理部分响应。 #### 4. **总结关键点** - **核心原因**: TCP的流特性（无消息边界）和内核缓冲机制是count不一致的根本；网络波动和应用逻辑则放大该问题。 - **是否正常**: 在TCP协议中轻度count不一致是正常现象，但如果count频繁为0或极大异常值，可能表示网络故障或程序bug（需检查错误代码）。 - **可靠性提示**: 在实际设备通信中（如电子水尺读取），引用[5]展示了通过数据解析和日志管理来应对count变化，确保数据完整性。 如果您提供更多细节（如编程语言或设备类型），我可以给出更针对性的建议。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值