用Python采用Modbus-Tcp的方式读取PLC模块数据

已于 2024-01-25 15:50:22 修改
阅读量3.9k 收藏 21
点赞数
分类专栏： Python学习私人笔记 物联网 文章标签： python tcp/ip 物联网 IOT Modbus
于 2023-07-13 19:37:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/the_beginner/article/details/131709452
版权

使用计算器得到需要的寄存器地址

这里PLC地址是83,对应的程序16进制读取地址是53
实际上由于PLC地址从1开始，所以这里实际地址应该是52，因为计算机从0开始

在这里插入图片描述

使用网络调试助手生成报文

在这里插入图片描述

使用Python中的内置函数int()。以下是将人员卡号’b’3b44’'转换为十进制的示例代码：

card_number = '3b44'
decimal_number = int(card_number, 16)
print(decimal_number)

使用response[-4:]获取了响应数据的后4个字节作为value96。然后，通过struct.unpack(‘>f’, value96)[0]将4字节的二进制字符串解包为单精度浮点数，并将其打印出来。

#实时电量
request = bytes.fromhex("00 20 00 00 00 06 01 03 00 5F 00 02 ")
client_socket.send(request)
response = client_socket.recv(1024)

value96 = response[-4:]
value96 = struct.unpack('>f', value96)[0]
value96=value96*10.00
value96=round(value96,2)
print("实时电量 单精度浮点数: {:.2f}".format(value96))

value40 是一个包含两个字节的字节串，即 b’\x00\x00’,将其转换为二进制，并保留8位。

以下是将字节串转换为二进制并保留8位的示例代码：

value40 = b'\x00\x00'
binary_value = bin(int.from_bytes(value40, byteorder='big'))[2:].zfill(8)
print("状态:", binary_value)

DEMO代码

#!D:/workplace/python
# -*- coding: utf-8 -*-
# @File  : main0523_04.py
# @Author:Romulushe
# @Time    : 2023/5/23 10:38
# @Software: PyCharm
# @Use: PyCharm
import socket
import struct
import time
import binascii

interval = 5
ip_address = ''#根据实际情况自定义
port_number = 502
polling_interval = float(interval)

def print_binary_value(value, name):
    binary_value = bin(int.from_bytes(value, byteorder='big'))[2:].zfill(8)[::-1]
    print(f"{name}: {binary_value}")

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client_socket:
    try:
        client_socket.settimeout(3)
        client_socket.connect((ip_address, port_number))

        while True:
            try:
                ##电压
                request = bytes.fromhex("00 22 00 00 00 06 01 03 00 53 00 02 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value84 = response[-4:]
                value84= struct.unpack('>f', value84)[0]
                # value84 = value84 * 10.00
                value84 = round(value84, 2)
                print("实时电压 单精度浮点数: {:.2f}".format(value84))

                ##电流
                request = bytes.fromhex("00 24 00 00 00 06 01 03 00 4F 00 02  ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value80 = response[-4:]
                value80 = struct.unpack('>f', value80)[0]
                # value84 = value80 * 10.00
                value80 = round(value80, 2)
                print("实时电流 单精度浮点数: {:.2f}".format(value80))

                ##实时温度1
                request = bytes.fromhex("00 2E 00 00 00 06 01 03 00 57 00 02 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value88 = response[-4:]
                value88 = struct.unpack('>f', value88)[0]
                # value88 = value88 * 10.00
                value88 = round(value88, 2)
                print("实时温度1 单精度浮点数: {:.2f}".format(value88))

                #实时温度2
                request = bytes.fromhex("00 2C 00 00 00 06 01 03 00 5B 00 02 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value92 = response[-4:]
                value92 = struct.unpack('>f', value92)[0]
                # value92 = value92 * 10.00
                value92 = round(value92, 2)
                print("实时温度2 单精度浮点数: {:.2f}".format(value92))

                ##车速
                request = bytes.fromhex("00 31 00 00 00 06 01 03 00 3B 00 01 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                speed= binascii.hexlify(response)[-4:]
                speed = int(speed, 16)
                print("车速:", speed)

                # #实时电量
                request = bytes.fromhex("00 20 00 00 00 06 01 03 00 5F 00 02 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value96 = response[-4:]
                value96 = struct.unpack('>f', value96)[0]
                value96=value96*10.00
                value96=round(value96,2)
                print("实时电量 单精度浮点数: {:.2f}".format(value96))

                #充放电状态

                #超速报警

                #低电量报警

                #温度过高1

                #温度过高2

                #00 18 00 00 00 06 01 03 00 28 00 01
                request = bytes.fromhex("00 33 00 00 00 06 01 03 00 28 00 01 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value40 = response[-2:]
                value40= bin(int.from_bytes(value40, byteorder='big'))[2:].zfill(8)[::-1]
                print("充放电状态:",value40[4])
                print("超速报警:", value40[0])
                print("低电量报警:", value40[2])
                print("温度1过高:", value40[3])
                print("温度2过高:", value40[7])


                #车牌号
                #
                request = bytes.fromhex("00 00 00 00 00 06 01 03 00 1E 00 02 ")  # 车牌号
                client_socket.send(request)
                response = client_socket.recv(1024)

                car_num= binascii.hexlify(response)[-8:-4]
                car_num = int(car_num, 16)
                print("车牌号:", car_num)

                #人员卡号
                request = bytes.fromhex("00 00 00 00 00 06 01 03 00 42 00 02 ")  # 人员卡号
                client_socket.send(request)
                response = client_socket.recv(1024)

                card = binascii.hexlify(response)[-8:-4]
                card = int(card, 16)
                print("人员卡号:", card)

            except socket.timeout:
                print('TIMEOUT ERROR: 服务器未及时响应')
    except Exception as e:
        print('CONNECT ERROR:', e)

DEMO结果

E:\software\python\python.exe E:/projects/Forklift/t2.py

实时电压 单精度浮点数: 48.85

实时电流 单精度浮点数: 0.26

实时温度1 单精度浮点数: 31.10

实时温度2 单精度浮点数: 30.85

车速: 0

实时电量 单精度浮点数: 68.52

充放电状态: 0

超速报警: 0

低电量报警: 0

温度1过高: 0

温度2过高: 0

车牌号: 15172

人员卡号: 10763

其他：地址表

在这里插入图片描述

附带数据库&log存储的代码：

#!D:/workplace/python
# -*- coding: utf-8 -*-
# @File  : main0523_04.py
# @Author:Romulushe
# @Time    : 2023/5/23 10:38
# @Software: PyCharm
# @Use: PyCharm
import socket
import struct
import time
import binascii
import pymysql
import os,sys,datetime,logging

interval = 5
ip_address = ''#根据实际情况自定义
port_number = ''#根据实际情况自定义
polling_interval = float(interval)


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 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}")


with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client_socket:
    configure_logging()
    cleanup_logs()

    log_filepath = create_new_log()

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

    try:
        client_socket.settimeout(3)
        client_socket.connect((ip_address, port_number))

        # 连接数据库
        host = ''#根据实际情况自定义
        port = 3306
        user = ''#根据实际情况自定义
        password = ''#根据实际情况自定义
        db_name = ''#根据实际情况自定义
        table_name =''#根据实际情况自定义
        try:
            # 连接数据库
            conn = connect_database(host, port, user, password, db_name)
        except Exception as e:
            print("COON ERROR:",e)

        while True:

            try:
                types ='叉车'
                location ='F2堆02'



                ##电压
                request = bytes.fromhex("00 22 00 00 00 06 01 03 00 53 00 02 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value84 = response[-4:]
                value84= struct.unpack('>f', value84)[0]
                # value84 = value84 * 10.00
                value84 = round(value84, 2)
                print("实时电压 单精度浮点数: {:.2f}".format(value84))

                location_no ='F01-1'
                parameter_desc ='实时电压'
                param_value=value84

                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                ##电流
                request = bytes.fromhex("00 24 00 00 00 06 01 03 00 4F 00 02  ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value80 = response[-4:]
                value80 = struct.unpack('>f', value80)[0]
                # value84 = value80 * 10.00
                value80 = round(value80, 2)
                print("实时电流 单精度浮点数: {:.2f}".format(value80))
                location_no = 'F01-2'
                parameter_desc = '实时电流'
                param_value=value80

                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                ##实时温度1
                request = bytes.fromhex("00 2E 00 00 00 06 01 03 00 57 00 02 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value88 = response[-4:]
                value88 = struct.unpack('>f', value88)[0]
                # value88 = value88 * 10.00
                value88 = round(value88, 2)
                print("实时温度1 单精度浮点数: {:.2f}".format(value88))
                location_no = 'F01-3'
                parameter_desc = '实时温度1'
                param_value = value88

                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

               #实时温度2
                request = bytes.fromhex("00 2C 00 00 00 06 01 03 00 5B 00 02 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value92 = response[-4:]
                value92 = struct.unpack('>f', value92)[0]
                # value92 = value92 * 10.00
                value92 = round(value92, 2)
                print("实时温度2 单精度浮点数: {:.2f}".format(value92))
                location_no = 'F01-4'
                parameter_desc = '实时温度2'
                param_value = value92

                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                ##车速
                request = bytes.fromhex("00 31 00 00 00 06 01 03 00 3B 00 01 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                speed= binascii.hexlify(response)[-4:]
                speed = int(speed, 16)
                print("车速:", speed)
                location_no = 'F01-5'
                parameter_desc = '车速'
                param_value = speed

                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                # #实时电量
                request = bytes.fromhex("00 20 00 00 00 06 01 03 00 5F 00 02 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value96 = response[-4:]
                value96 = struct.unpack('>f', value96)[0]
                value96=value96*10.00
                value96=round(value96,2)
                print("实时电量 单精度浮点数: {:.2f}".format(value96))
                location_no = 'F01-6'
                parameter_desc = '实时电量'
                param_value = value96

                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                #充放电状态

                #超速报警

                #低电量报警

                #温度过高1

                #温度过高2

                #00 18 00 00 00 06 01 03 00 28 00 01
                request = bytes.fromhex("00 33 00 00 00 06 01 03 00 28 00 01 ")
                client_socket.send(request)
                response = client_socket.recv(1024)

                value40 = response[-2:]
                value40= bin(int.from_bytes(value40, byteorder='big'))[2:].zfill(8)[::-1]
                print("充放电状态:",value40[4])
                print("超速报警:", value40[0])
                print("低电量报警:", value40[2])
                print("温度1过高:", value40[3])
                print("温度2过高:", value40[7])
                location_no = 'F01-7'
                parameter_desc = '充放电状态'
                param_value = value40[4]
                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                location_no = 'F01-8'
                parameter_desc = '超速报警'
                param_value = value40[0]
                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                location_no = 'F01-9'
                parameter_desc = '低电量报警'
                param_value = value40[2]
                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                location_no = 'F01-10'
                parameter_desc = '温度1过高'
                param_value = value40[3]
                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                location_no = 'F01-11'
                parameter_desc = '温度2过高'
                param_value = value40[7]
                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                # 车牌号
                #
                request = bytes.fromhex("00 00 00 00 00 06 01 03 00 1E 00 02 ")  # 车牌号
                client_socket.send(request)
                response = client_socket.recv(1024)

                car_num = binascii.hexlify(response)[-8:-4]
                car_num = int(car_num, 16)
                print("车牌号:", car_num)
                location_no = 'F01-12'
                parameter_desc = '车牌号'
                param_value = car_num
                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

                # 人员卡号
                request = bytes.fromhex("00 00 00 00 00 06 01 03 00 42 00 02 ")  # 人员卡号
                client_socket.send(request)
                response = client_socket.recv(1024)

                card = binascii.hexlify(response)[-8:-4]
                card = int(card, 16)
                print("人员卡号:", card)
                location_no = 'F01-13'
                parameter_desc = '人员卡号'
                param_value = card
                insert_data(conn, types, table_name, create_time, location_no, parameter_desc, location, param_value)

            except socket.timeout:
                print('TIMEOUT ERROR: 服务器未及时响应')
    except Exception as e:
        print('CONNECT ERROR:', e)
python使用modbustcp协议与PLC进行简单通信
AI相关从业分享
05-29 1103
要使用pymodbus框架对PLC（如PLC 1512c，假设它支持Modbus协议）进行读和写操作，你需要首先确定PLC的Modbus地址、端口号、设备ID（单元标识符）以及你想要读写的寄存器类型（如线圈、离散输入、输入寄存器或保持寄存器）。Modbus协议：是一种广泛使用的通信协议，用于工业自动化系统。可以使用pymodbus库在Python中实现Modbus客户端或服务器。python使用modbustcp协议与PLC进行简单通信。
python modbus-tk 实现三菱FX5U modbus-tcp 从站通讯
jxjk1979的博客
07-30 7394
python struct modbus tcp FX5U modbus-tk
python 读写PLC实例
06-28
python 使用 snap7 实现西门子 plc 1200的读写 地址读写
利用python获取modbus tcp数据
weixin_35749786的博客
02-11 1159
要利用 Python 获取 Modbus TCP 数据，您可以使用第三方库如 pymodbus。您可以通过以下步骤操作： 安装 pymodbus：运行 pip install pymodbus。 导入 pymodbus 库：在 Python 代码中导入 import modbus_tk.modbus_tcp as modbus_tcp。 创建 Modbus TCP 客户端：使用 client =...
ROS利用Modbus协议，读取PLC数据并发布
最新发布
laoli_的博客
03-19 149
二、建立客户端程序并发布。
Python 批量读取西门子PLC
qq_34677276的博客
08-14 675
Python 批量读取西门子PLC
PYTHON循环读取PLC的数据并实时保存到数据库Mysql
m0_68793455的博客
03-12 1192
需要用的库有pymysql，time，snap7。需要提交sql语句：con.commit()1.python连接到本地的mysql数据。因为要循环读取所以使用while True。host：连接的本地的数据库的名称。port：端口号，默认为3306。charset：字符编码。3.将数据写入到数据库中。password：密码。2.连接plc读取数据。# 创建通讯客户端实例。确定数据在PLC的位置。时间根据自己的要求设定。
基于Python的ModbusTCP客户端实现
weixin_34252090的博客
02-22 1152
Modbus协议是由Modicon公司（现在的施耐德电气Schneider Electric）推出，主要建立在物理串口、以太网TCP/IP层之上，目前已经成为工业领域通信协议的业界标准，广泛应用在工业电子设备之间的互联。Modbus Poll和Modbus Slave是两款非常流行的Modbus设备仿真软件，支持Modbus RTU/ASCII和Modbus TCP/IP协议 ，经常用于测试和调试...
modbus-tcp-master.zip
07-09
1. **源代码**：可能是用C、Python、Java等语言编写的Modbus TCP主站实现。主站负责发起请求，读取或写入从站设备的寄存器值。 2. **文档**：可能包含关于如何使用这些代码的说明，包括API接口、示例代码和配置指南...
Python3 Modbus TCP Server 为PLC做服务器端提供数据
monkey的博客
12-02 2100
需要安装 modbus_tk 模块 pip install modbus_tk 以下代码是开启Modbus TCP Server服务，然后不断读取最新的TXT文件的数据，将新数据存储到保持寄存器并覆盖旧数据，供PLC读取。 import re import sys from time import sleep import modbus_tk import modbus_tk.defines as cst import os from modbus_tk import modbus_tcp # dir
python通过pymodbus模块和施耐德TM251 PLC进行ModbusTCP通信，读写PLC数据
u010271276的博客
02-05 1425
python 和施耐德PLC通过modbus tcp 通信协议进行数据读写操作
ModbusTCP测试，可读写PLC等设备
01-04
ModbusTCP测试，可读写PLC等设备，根据设置的IP地址和端口连接设备
用Python写的Modbus-TCP/IP客户端
08-06
用Python写的Modbus-TCP/IP客户端，可用，文档虽小，但功能能实现，请需要的朋友下载，更改后就可以是自己的了
C#编成Modbus TCP连接PLC寄存器读取、写入
05-07
C#编成Modbus TCP连接PLC寄存器读取、写入，完整分享源代码，有需要的人可以下载
PC通过数据网关读写plc寄存器的python通信协议
06-30
使用西门子S7-200CN PLC，V4.0 STEP 7 MicroWIN SP9上导入Modbus Slave Port0(v1.0)，下载slave.mwp到PLC并运行，串口连接PLC与数据采集网关（PC、树莓派或开发板），运行数据采集网关上的server.py，运行另一台PC上的client.py
通过MODBUS TCP读写PLC源码
01-23
通过MODBUS TCP读写PLC源码,是c#代码，可以作为参考
python实时读plc数据_Python读取实时数据流示例
weixin_39813263的博客
11-28 1051
1、#coding:utf-8chose = [('foo',1,2),('bar','hello'),('foo',3,4)]def do_foo(x,y):print('foo',x,y)def do_bar(s):print('bar',s)for tag,*args in chose:if tag == 'foo':do_foo(*args)elif tag == 'bar':do_bar...
使用Python读取西门子PLC寄存器数据的实现方法
weixin_67244432的博客
03-29 2090
使用Python结合S7协议读取西门子PLC寄存器数据
C#通过ModbusTcp协议读写西门子PLC中的浮点数
热门推荐
hqwest的专栏
09-04 1万+
MODBUS/TCP是简单的、中立厂商的用于管理和控制自动化设备的MODBUS系列通讯协议的派生产品，显而易见，它覆盖了使用TCP/IP协议的“Intranet”和“Internet”环境中MODBUS报文的用途。协议的最通用用途是为诸如PLC，I/O模块，以及连接其它简单域总线或I/O模块的网关服务的。Modbus TCP协议是在RTU协议前面添加MBAP报文头，由于TCP是基于可靠连接的服务，RTU协议中的CRC校验码就不再需要，所以在Modbus TCP协议中是没有CRC校验码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值