327 lines
13 KiB
Python
327 lines
13 KiB
Python
import logging
|
|
import threading
|
|
from pymodbus.client import ModbusSerialClient
|
|
from pymodbus.exceptions import ModbusException, ConnectionException
|
|
import time
|
|
from config import *
|
|
|
|
logging.basicConfig(level=logging.INFO)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
RETRIES = 2
|
|
RECONNECT_INTERVAL = 0.1 # 优化重连间隔时间(秒)
|
|
|
|
class ModbusClient:
|
|
def __init__(self):
|
|
self.client = None
|
|
#使用普通锁
|
|
self.serial_lock = threading.Lock()
|
|
|
|
try:
|
|
port = config.get("interface", {}).get("port", "/dev/ttyModbus")
|
|
if port:
|
|
self.port = port
|
|
except:
|
|
pass
|
|
|
|
try:
|
|
baudrate = config.get("interface", {}).get("baudrate", 115200)
|
|
if baudrate:
|
|
self.baudrate = baudrate
|
|
except:
|
|
pass
|
|
|
|
def acquire_lock(self):
|
|
self.serial_lock.acquire()
|
|
|
|
def release_lock(self):
|
|
self.serial_lock.release()
|
|
|
|
def connect(self):
|
|
"""建立Modbus RTU连接"""
|
|
try:
|
|
# 连接操作也需要写锁保护
|
|
self.acquire_lock()
|
|
if self.client:
|
|
try:
|
|
self.client.close()
|
|
except:
|
|
pass
|
|
finally:
|
|
self.client = None
|
|
try:
|
|
self.client = ModbusSerialClient(
|
|
port=self.port,
|
|
baudrate=self.baudrate,
|
|
bytesize=BYTESIZE,
|
|
parity=PARITY,
|
|
stopbits=STOPBITS,
|
|
timeout=TIMEOUT
|
|
)
|
|
|
|
if self.client.connect():
|
|
logger.info(f"成功连接到Modbus串口: {self.port}")
|
|
return True
|
|
else:
|
|
logger.error(f"Modbus串口连接失败: {self.port}")
|
|
return False
|
|
finally:
|
|
self.release_lock()
|
|
except Exception as e:
|
|
logger.error(f"Modbus连接异常: {str(e)}")
|
|
|
|
return False
|
|
|
|
def disconnect(self):
|
|
"""断开Modbus连接"""
|
|
try:
|
|
self.acquire_lock()
|
|
try:
|
|
if self.client:
|
|
self.client.close()
|
|
logger.info("已断开Modbus连接")
|
|
finally:
|
|
self.client = None
|
|
self.release_lock()
|
|
except Exception as e:
|
|
logger.error(f"断开连接异常: {str(e)}")
|
|
|
|
|
|
def read_input_registers(self, slave_id, address, count):
|
|
"""读取输入寄存器,包含重试机制和线程锁保护"""
|
|
|
|
# 先确保连接正常,减少锁内操作
|
|
if self.client is None or not self.client.is_socket_open():
|
|
logger.error(f"无法确保Modbus连接,无法读取输入寄存器 (从站{slave_id}, 地址{address})")
|
|
return None
|
|
|
|
try:
|
|
# 只在实际读写操作时使用锁,减少锁持有时间
|
|
self.acquire_lock()
|
|
try:
|
|
response = self.client.read_input_registers(
|
|
address=address,
|
|
count=count,
|
|
device_id=slave_id
|
|
)
|
|
finally:
|
|
self.release_lock()
|
|
|
|
# 检查响应
|
|
if response.isError():
|
|
logger.error(f"读取输入寄存器错误: 从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES}, 错误: {response}")
|
|
# 非致命错误不立即重连,仅在最后一次尝试失败后重连
|
|
|
|
logger.debug(f"成功读取输入寄存器: 从站{slave_id}, 地址{address}, 值: {response.registers}")
|
|
return response.registers
|
|
except ModbusException as e:
|
|
logger.error(f"Modbus协议错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
|
|
except Exception as e:
|
|
logger.error(f"读取输入寄存器异常: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
|
|
return None
|
|
|
|
def read_coils(self, slave_id, address, count):
|
|
"""读取线圈状态,包含重试机制和线程锁保护"""
|
|
|
|
# 先确保连接正常,减少锁内操作
|
|
if self.client is None or not self.client.is_socket_open():
|
|
logger.error(f"无法确保Modbus连接,无法读取线圈 (从站{slave_id}, 地址{address})")
|
|
return None
|
|
|
|
try:
|
|
# 只在实际读写操作时使用锁,减少锁持有时间
|
|
self.acquire_lock()
|
|
try:
|
|
response = self.client.read_coils(
|
|
address=address,
|
|
count=count,
|
|
device_id=slave_id
|
|
)
|
|
finally:
|
|
self.release_lock()
|
|
|
|
# 检查响应
|
|
if response.isError():
|
|
logger.error(f"读取线圈错误: 从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES}, 错误: {response}")
|
|
|
|
logger.debug(f"成功读取线圈: 从站{slave_id}, 地址{address}, 值: {response.bits[:count]}")
|
|
return response.bits[:count]
|
|
except ModbusException as e:
|
|
logger.error(f"Modbus协议错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
|
|
except Exception as e:
|
|
logger.error(f"读取线圈异常: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
|
|
return None
|
|
|
|
def read_discrete(self, slave_id, address, count):
|
|
"""读取离散输入状态,包含重试机制和线程锁保护"""
|
|
# 先确保连接正常,减少锁内操作
|
|
if self.client is None or not self.client.is_socket_open():
|
|
logger.error(f"无法确保Modbus连接,无法读取离散输入 (从站{slave_id}, 地址{address})")
|
|
return None
|
|
|
|
try:
|
|
# 只在实际读写操作时使用锁,减少锁持有时间
|
|
self.acquire_lock()
|
|
try:
|
|
response = self.client.read_discrete_inputs(
|
|
address=address,
|
|
count=count,
|
|
device_id=slave_id
|
|
)
|
|
finally:
|
|
self.release_lock()
|
|
|
|
# 检查响应
|
|
if response.isError():
|
|
logger.error(f"读取离散输入错误: 从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES}, 错误: {response}")
|
|
|
|
logger.debug(f"成功读取离散输入: 从站{slave_id}, 地址{address}, 值: {response.bits[:count]}")
|
|
return response.bits[:count]
|
|
except ModbusException as e:
|
|
logger.error(f"Modbus协议错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
|
|
except Exception as e:
|
|
logger.error(f"读取离散输入异常: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
|
|
return None
|
|
|
|
def _ensure_connection(self) -> bool:
|
|
"""确保Modbus连接正常
|
|
|
|
Returns:
|
|
bool: 连接是否正常
|
|
"""
|
|
self.acquire_lock()
|
|
try:
|
|
if self.client and self.client.is_socket_open():
|
|
return True
|
|
return self.connect()
|
|
finally:
|
|
self.release_lock()
|
|
|
|
def write_coil(self, slave_id: int, address: int, value: bool) -> bool:
|
|
"""写入线圈状态,带重试机制和线程锁保护
|
|
|
|
Args:
|
|
slave_id: 从站地址
|
|
address: 线圈地址
|
|
value: 线圈状态(True/False)
|
|
|
|
Returns:
|
|
bool: 写入是否成功
|
|
"""
|
|
# 先确保连接正常,减少锁内操作
|
|
if not self._ensure_connection():
|
|
logger.error(f"无法确保Modbus连接,无法写入线圈 (从站{slave_id}, 地址{address})")
|
|
return False
|
|
|
|
for attempt in range(RETRIES):
|
|
try:
|
|
# 只在实际写操作时使用锁,减少锁持有时间
|
|
self.acquire_lock()
|
|
response = None
|
|
try:
|
|
logger.debug(f"发送写入线圈请求: 从站{slave_id}, 地址{address}, 状态{value}")
|
|
response = self.client.write_coil(address, value, device_id=slave_id)
|
|
finally:
|
|
self.release_lock()
|
|
|
|
if response:
|
|
# 检查响应
|
|
if response.isError():
|
|
logger.error(f"写入线圈错误响应: 从站{slave_id}, 地址{address} (尝试{attempt+1}/{RETRIES})")
|
|
# 非致命错误不立即重连,仅在最后一次尝试失败后重连
|
|
if attempt < RETRIES - 1:
|
|
time.sleep(0.05) # 使用更短的延迟
|
|
continue
|
|
else:
|
|
logger.debug(f"接收到写入线圈响应: 长度{len(response.encode())}字节, 内容{response.encode().hex()}")
|
|
|
|
# 快速释放锁,减少其他操作等待时间
|
|
|
|
logger.info(f"成功写入线圈 {address}: {value} (尝试{attempt+1}/{RETRIES})")
|
|
return True
|
|
except ConnectionException as e:
|
|
logger.error(f"连接中断错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
self.connected = False # 修正变量名
|
|
if attempt < RETRIES - 1:
|
|
time.sleep(0.05)
|
|
except ModbusException as e:
|
|
logger.error(f"Modbus协议错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
|
|
if attempt < RETRIES - 1:
|
|
time.sleep(0.05)
|
|
except Exception as e:
|
|
logger.error(f"写入线圈未知错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
|
|
if attempt < RETRIES - 1:
|
|
time.sleep(0.05)
|
|
|
|
logger.error(f"所有{RETRIES}次写入线圈尝试均失败: 从站{slave_id}, 地址{address}")
|
|
return False
|
|
|
|
def write_holding_register(self, slave_id: int, address: int, value: int) -> bool:
|
|
"""写入保持寄存器,带重试机制和线程锁保护
|
|
|
|
Args:
|
|
slave_id: 从站地址
|
|
address: �保持寄存器地址
|
|
value: 保持寄存器值
|
|
|
|
Returns:
|
|
bool: 写入是否成功
|
|
"""
|
|
# 先确保连接正常,减少锁内操作
|
|
if not self._ensure_connection():
|
|
logger.error(f"无法确保Modbus连接,无法写入保持寄存器 (从站{slave_id}, 地址{address})")
|
|
return False
|
|
|
|
for attempt in range(RETRIES):
|
|
try:
|
|
# 只在实际写操作时使用锁,减少锁持有时间
|
|
self.acquire_lock()
|
|
response = None
|
|
try:
|
|
logger.debug(f"发送写入保持寄存器请求: 从站{slave_id}, 地址{address}, 值{value}")
|
|
response = self.client.write_register(address, value, device_id=slave_id)
|
|
finally:
|
|
self.release_lock()
|
|
|
|
if response:
|
|
# 检查响应
|
|
if response.isError():
|
|
logger.error(f"写入保持寄存器错误响应: 从站{slave_id}, 地址{address} (尝试{attempt+1}/{RETRIES})")
|
|
# 非致命错误不立即重连,仅在最后一次尝试失败后重连
|
|
if attempt < RETRIES - 1:
|
|
time.sleep(0.05) # 使用更短的延迟
|
|
continue
|
|
else:
|
|
logger.debug(f"接收到写入保持寄存器响应: 长度{len(response.encode())}字节, 内容{response.encode().hex()}")
|
|
|
|
# 快速释放锁,减少其他操作等待时间
|
|
|
|
logger.info(f"成功写入保持寄存器 {address}: {value} (尝试{attempt+1}/{RETRIES})")
|
|
return True
|
|
except ConnectionException as e:
|
|
logger.error(f"连接中断错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
self.connected = False # 修正变量名
|
|
if attempt < RETRIES - 1:
|
|
time.sleep(0.05)
|
|
except ModbusException as e:
|
|
logger.error(f"Modbus协议错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
|
|
if attempt < RETRIES - 1:
|
|
time.sleep(0.05)
|
|
except Exception as e:
|
|
logger.error(f"写入保持寄存器未知错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})")
|
|
|
|
if attempt < RETRIES - 1:
|
|
time.sleep(0.05)
|
|
|
|
logger.error(f"所有{RETRIES}次写入保持寄存器尝试均失败: 从站{slave_id}, 地址{address}")
|
|
return False
|