python如何用pymodbus库进行modbus tcp通信

黄凯鹏

使用pymodbus库进行modbus tcp通信

使用python解决工业通信问题是一个非常好的选择，python具有丰富的生态，可以轻松解决工业通信的各种问题。
本篇主要介绍使用pymodbus库进行modbus tcp仿真，实现pc端读取plc或工业设备modbus变量。
安装pymodbus：

1. pip install -U pymodbus

复制代码

创建modbus tcp server

这里我们先创建一个虚拟的modbus设备，如果你手里有一个plc或者工业设备，可以直接跳过本节。

• modbus_server.py
  

1. '''
   
2. * @Author: liuzhao
   
3. * @Last Modified time: 2022-10-05 09:56:13
   
4. '''
   
5. 
   
6. from pymodbus.server.sync import (
   
7.     StartTcpServer,
   
8. )
   
9. from pymodbus.datastore import (
   
10.     ModbusSequentialDataBlock,
    
11.     ModbusServerContext,
    
12.     ModbusSlaveContext,
    
13. )
    
14. from pymodbus.version import version
    
15. 
    
16. datablock = ModbusSequentialDataBlock.create()
    
17. context = ModbusSlaveContext(
    
18.     di=datablock,
    
19.     co=datablock,
    
20.     hr=datablock,
    
21.     ir=datablock,
    
22.     )
    
23. single = True
    
24. 
    
25. # Build data storage
    
26. store = ModbusServerContext(slaves=context, single=single)
    
27. 
    
28. 
    
29. if __name__ == '__main__':
    
30. 
    
31.         address = ("0.0.0.0", 503)
    
32.         StartTcpServer(
    
33.             context=store,  # Data storage
    
34.             address=address,  # listen address
    
35.                   allow_reuse_address=True,  # allow the reuse of an address
    
36.         )

复制代码

直接运行该脚本，就可以在本机的503端口创建一台modbus设备了，具体实现暂不深追，我们学习的重点是客户端对modbus变量的读写。

读写modbus变量


modbus变量类型以及地址

Object typeAccessSizeAddressCoilRead-write1 bit00001 – 09999Discrete inputRead-only1 bit10001 – 19999Input registerRead-only16 bits30001 – 39999Holding registerRead-write16 bits40001 – 49999coil是线圈，Discrete input是数字量输入，Input register是模拟量输入，Holding register是保持寄存器。一般地址范围是0-65535

读取常规变量

读写线圈 | 读取输入变量 | 读写保持寄存器

1. from pymodbus.client.sync import ModbusTcpClient
   
2. from pymodbus.bit_read_message import ReadCoilsResponse
   
3. from pymodbus.register_read_message import ReadInputRegistersResponse
   
4. from pymodbus.exceptions import ConnectionException      # 连接失败，用于异常处理
   
5. 
   
6. host = '127.0.0.1'
   
7. port = 503
   
8. client = ModbusTcpClient(host,port)
   
9. 
   
10. 
    
11. # 写入线圈
    
12. client.write_coil(1, True)
    
13. client.write_coil(2, False)
    
14. client.write_coil(3, True)
    
15. 
    
16. # 读取线圈    注意对于离散量的读取，第二个参数cout是有坑的，必须为8的倍数个
    
17. result:ReadCoilsResponse = client.read_coils(address=1,cout=8)     # 从地址1开始读，读取8个线圈，一次读8的倍数个线圈，不设置为8的倍数可能会出现问题
    
18. print(result.isError())
    
19. 
    
20. # 不建议使用
    
21. print(result.getBit(7))            # 这里的参数address不是plc里的地址，而是python列表的address，
    
22. 
    
23. print('read_coils ')
    
24. 
    
25. # 建议使用
    
26. print(result.bits)        # 打印读取结果，一共8位
    
27. # 读取其中的位
    
28. print(                  
    
29.     result.bits[0],
    
30.     result.bits[1],
    
31.     result.bits[2]
    
32.     )         # 相当于result.getBit(0)
    
33. 
    
34. 
    
35. # 读取数字输入
    
36. result = client.read_discrete_inputs(address=10001,count=8)    # 从10001开始读，读取8位
    
37. print(result.bits)
    
38. 
    
39. 
    
40. # 读取模拟输入寄存器
    
41. input_register_result:ReadInputRegistersResponse = client.read_input_registers(1,count=8)
    
42. # print(f'is_error:{input_register_result.isError()}')
    
43. print('read_input_registers ')
    
44. print(input_register_result.registers)   
    
45. print(input_register_result.getRegister(0))   
    
46. 
    
47. 
    
48. # 读写保持寄存器
    
49. client.write_register(address=40001,value=100)
    
50. result:ReadInputRegistersResponse = client.read_holding_registers(address=40001,count=1)
    
51. print('read_holding_registers ')
    
52. print(result.registers)
    
53. 
    
54. ＃　关闭连接
    
55. client.close()

复制代码

读取复杂变量

字符串、浮点数、负数等
这里需要注意modbus设备的存储结构是低位低字节还是低位高字节，也就是设备内存的字节、字的排列顺序。
根据不同的设备，对照下表调整正确的组合方式。
Word OrderByte orderWord1Word2BigBig0x12340x5678BigLittle0x34120x7856LittleBig0x56780x1234LittleLittle0x78560x3412

1. # 复杂数据类型
   
2. 
   
3. from collections import OrderedDict
   
4. import logging
   
5. 
   
6. from pymodbus.client.sync import ModbusTcpClient as ModbusClient
   
7. 
   
8. from pymodbus.constants import Endian
   
9. from pymodbus.payload import BinaryPayloadBuilder, BinaryPayloadDecoder
   
10. 
    
11. 
    
12. 
    
13. ORDER_DICT = {"<": "LITTLE", ">": "BIG"}
    
14. 
    
15. 
    
16. def run_binary_payload_client(host:str,port:int):
    
17.   
    
18.     for word_endian, byte_endian in (
    
19.         (Endian.Big, Endian.Big),
    
20.         (Endian.Big, Endian.Little),
    
21.         (Endian.Little, Endian.Big),
    
22.         (Endian.Little, Endian.Little),
    
23.     ):
    
24.         print("-" * 60)
    
25.         print(f"Word Order: {ORDER_DICT[word_endian]}")
    
26.         print(f"Byte Order: {ORDER_DICT[byte_endian]}")
    
27.         print()
    
28.    
    
29.         builder = BinaryPayloadBuilder(
    
30.             wordorder=word_endian,
    
31.             byteorder=byte_endian,
    
32.         )
    
33.                
    
34.                 # 写入的变量
    
35.         my_string = "abcd-efgh123345765432"
    
36.         builder.add_string(my_string)
    
37.         builder.add_bits([0, 1, 0, 1, 1, 0, 1, 0])
    
38.         builder.add_8bit_int(-0x12)
    
39.         builder.add_8bit_uint(0x12)
    
40.         builder.add_16bit_int(-0x5678)
    
41.         builder.add_16bit_uint(0x1234)
    
42.         builder.add_32bit_int(-0x1234)
    
43.         builder.add_32bit_uint(0x12345678)
    
44.         builder.add_16bit_float(12.34)
    
45.         builder.add_16bit_float(-12.34)
    
46.         builder.add_32bit_float(22.34)
    
47.         builder.add_32bit_float(-22.34)
    
48.         builder.add_64bit_int(-0xDEADBEEF)
    
49.         builder.add_64bit_uint(0x12345678DEADBEEF)
    
50.         builder.add_64bit_uint(0x12345678DEADBEEF)
    
51.         builder.add_64bit_float(123.45)
    
52.         builder.add_64bit_float(-123.45)
    
53.         registers = builder.to_registers()
    
54.         print("Writing Registers:")
    
55.         print(registers)
    
56.         print("\n")
    
57.         payload = builder.build()
    
58.         address = 40001          # 从40001开始写入
    
59.         # We can write registers
    
60.         client.write_registers(address, registers, unit=1)    # 写入
    
61.             
    
62.              # 读取复杂变量
    
63.         print("Reading Registers:")
    
64.         address = 40001
    
65. 
    
66.         count = len(payload)
    
67.         print(f"payload_len {count}")
    
68.         result = client.read_holding_registers(address, count, slave=1)
    
69.         print(result.registers)
    
70.         print("\n")
    
71.         decoder = BinaryPayloadDecoder.fromRegisters(
    
72.             result.registers, byteorder=byte_endian, wordorder=word_endian
    
73.         )
    
74.         # Make sure word/byte order is consistent between BinaryPayloadBuilder and BinaryPayloadDecoder
    
75.         assert (
    
76.             decoder._byteorder == builder._byteorder  # pylint: disable=protected-access
    
77.         )  # nosec
    
78.         assert (
    
79.             decoder._wordorder == builder._wordorder  # pylint: disable=protected-access
    
80.         )  # nosec
    
81. 
    
82.         decoded = OrderedDict(
    
83.             [
    
84.                 ("string", decoder.decode_string(len(my_string))),
    
85.                 ("bits", decoder.decode_bits()),
    
86.                 ("8int", decoder.decode_8bit_int()),
    
87.                 ("8uint", decoder.decode_8bit_uint()),
    
88.                 ("16int", decoder.decode_16bit_int()),
    
89.                 ("16uint", decoder.decode_16bit_uint()),
    
90.                 ("32int", decoder.decode_32bit_int()),
    
91.                 ("32uint", decoder.decode_32bit_uint()),
    
92.                 ("16float", decoder.decode_16bit_float()),
    
93.                 ("16float2", decoder.decode_16bit_float()),
    
94.                 ("32float", decoder.decode_32bit_float()),
    
95.                 ("32float2", decoder.decode_32bit_float()),
    
96.                 ("64int", decoder.decode_64bit_int()),
    
97.                 ("64uint", decoder.decode_64bit_uint()),
    
98.                 ("ignore", decoder.skip_bytes(8)),
    
99.                 ("64float", decoder.decode_64bit_float()),
    
100.                 ("64float2", decoder.decode_64bit_float()),
     
101.             ]
     
102.         )
     
103.         print("Decoded Data")
     
104.         for name, value in iter(decoded.items()):
     
105.             print(
     
106.                 "%s\t" % name,  # pylint: disable=consider-using-f-string
     
107.                 hex(value) if isinstance(value, int) else value,
     
108.             )
     
109.         print("\n")
     
110. 
     
111.         # 关闭连接
     
112.     client.close()
     
113. 
     
114. 
     
115. if __name__ == "__main__":
     
116.     run_binary_payload_client("127.0.0.1", 503)   

复制代码

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

来源:https://www.jb51.net/python/323478l1j.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！