Python 线程池modbustcp连接多个设备实现读写

要实现Python多线程与多个Modbus TCP设备的读写操作，可以使用Python标准库中的`concurrent.futures`模块来创建线程池，从而实现并发处理。

下面是一个简单的示例代码，可以连接多个Modbus TCP设备，并且使用线程池实现读写操作：

import concurrent.futures
import time
import logging
import socket
import struct
import binascii

# modbus tcp client
class ModbusTCPClient:
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
        self.socket = None

    def connect(self):
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.connect((self.ip, self.port))

    def disconnect(self):
        self.socket.close()
        self.socket = None

    def read_registers(self, start_addr, count):
        request = struct.pack('>HHHH', 0x0001, start_addr, count, 0x0000)
        self.socket.send(request)
        response = self.socket.recv(1024)
        return struct.unpack_from('>' + 'H' * count, response, offset=9)

    def write_register(self, addr, value):
        request = struct.pack('>HHH', 0x0006, addr, value)
        self.socket.send(request)
        response = self.socket.recv(1024)
        return struct.unpack_from('>HH', response, offset=9)

# worker function for thread pool
def worker(ip, port, start_addr, count):
    client = ModbusTCPClient(ip, port)
    client.connect()
    try:
        # read registers
        values = client.read_registers(start_addr, count)
        logging.info('ip=%s, values=%s', ip, values)
        # write a value
        client.write_register(start_addr, 0x1234)
    except Exception as e:
        logging.error('ip=%s, error=%s', ip, str(e))
    finally:
        client.disconnect()

# main function
def main():
    # configure logging
    logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')

    # list of modbus tcp devices
    devices = [
        {'ip': '192.168.1.100', 'port': 502, 'start_addr': 0, 'count': 2},
        {'ip': '192.168.1.101', 'port': 502, 'start_addr': 2, 'count': 2},
        {'ip': '192.168.1.102', 'port': 502, 'start_addr': 4, 'count': 2},
    ]

    # create thread pool
    with concurrent.futures.ThreadPoolExecutor(max_workers=len(devices)) as executor:
        # submit tasks to thread pool
        futures = [executor.submit(worker, device['ip'], device['port'], device['start_addr'], device['count']) for device in devices]

        # wait for tasks to complete
        for future in concurrent.futures.as_completed(futures):
            try:
                future.result()
            except Exception as e:
                logging.error('error=%s', str(e))

# entry point
if __name__ == '__main__':
    main()

在上面的示例代码中，我们定义了一个`ModbusTCPClient`类来封装Modbus TCP客户端的连接和读写操作。然后定义了一个`worker()`函数作为线程池中的工作函数，用于连接Modbus TCP设备、执行读写操作并输出日志。最后，我们使用`concurrent.futures`模块来创建线程池，并且使用`executor.submit()`方法将任务提交到线程池中。任务完成后，我们使用`concurrent.futures.as_completed()`方法来等待所有任务完成并输出日志。

请注意，上述示例代码仅供参考，实际应用中需要根据具体情况进行修改。同时，多线程读写操作也需要考虑线程安全问题，例如使用锁来保证操作的原子性。