882 lines
38 KiB
Python
882 lines
38 KiB
Python
import threading
|
||
import time
|
||
import logging
|
||
from snap7.util import *
|
||
import struct
|
||
|
||
class CacheManager:
|
||
"""PLC数据缓存管理器"""
|
||
|
||
def __init__(self, config, plc_manager, app=None):
|
||
"""
|
||
初始化缓存管理器
|
||
|
||
Args:
|
||
config: 配置对象
|
||
plc_manager: PLC管理器实例
|
||
app: 主应用程序引用（用于配置重载）
|
||
"""
|
||
self.plc_manager = plc_manager
|
||
self.config = config
|
||
self.app = app
|
||
self.cache = {}
|
||
self.refresh_interval = 1 # 1秒刷新一次
|
||
self.running = False
|
||
self.lock = threading.Lock()
|
||
self.thread = None
|
||
self.last_update = {} # 区域级最后更新时间
|
||
self.plc_last_connected = {} # PLC级最后连接时间
|
||
self.plc_connection_status = {} # PLC连接状态
|
||
self.logger = logging.getLogger("CacheManager")
|
||
self.init_cache()
|
||
|
||
|
||
|
||
def init_cache(self):
|
||
"""初始化缓存结构"""
|
||
for plc in self.config["plcs"]:
|
||
plc_name = plc["name"]
|
||
self.cache[plc_name] = {}
|
||
self.last_update[plc_name] = {}
|
||
self.plc_last_connected[plc_name] = 0 # 初始化为0（未连接）
|
||
self.plc_connection_status[plc_name] = "never_connected"
|
||
|
||
for area in plc["areas"]:
|
||
name = area["name"]
|
||
# 确保初始状态为断开
|
||
self.cache[plc_name][name] = {
|
||
"data": bytearray(area["size"]),
|
||
"db_number": area["db_number"],
|
||
"offset": area["offset"],
|
||
"size": area["size"],
|
||
"type": area["type"],
|
||
"structure": area.get("structure", []),
|
||
"status": "disconnected" # 初始状态为断开
|
||
}
|
||
self.last_update[plc_name][name] = 0
|
||
|
||
def refresh_cache(self):
|
||
"""后台线程：定期刷新缓存"""
|
||
while self.running:
|
||
start_time = time.time()
|
||
|
||
try:
|
||
for plc in self.config["plcs"]:
|
||
plc_name = plc["name"]
|
||
refresh_interval = plc.get("refresh_interval", 0.5)
|
||
client = self.plc_manager.get_plc(plc_name)
|
||
|
||
# 检查PLC连接状态
|
||
plc_connected = client.connected
|
||
|
||
# 更新PLC连接状态
|
||
with self.lock:
|
||
if plc_connected:
|
||
self.plc_last_connected[plc_name] = time.time()
|
||
self.plc_connection_status[plc_name] = "connected"
|
||
else:
|
||
if self.plc_last_connected[plc_name] == 0:
|
||
self.plc_connection_status[plc_name] = "never_connected"
|
||
else:
|
||
self.plc_connection_status[plc_name] = "disconnected"
|
||
|
||
# 刷新所有可读区域
|
||
for area in plc["areas"]:
|
||
if area["type"] in ["read", "read_write"]:
|
||
name = area["name"]
|
||
try:
|
||
data = client.read_db(area["db_number"], area["offset"], area["size"])
|
||
|
||
# 更新区域状态基于PLC连接状态和读取结果
|
||
with self.lock:
|
||
if plc_connected and data and len(data) == area["size"]:
|
||
self.cache[plc_name][name]["data"] = bytearray(data)
|
||
self.cache[plc_name][name]["status"] = "connected"
|
||
self.last_update[plc_name][name] = time.time()
|
||
else:
|
||
self.cache[plc_name][name]["status"] = self.plc_connection_status[plc_name]
|
||
# 如果之前有数据，保留旧数据但标记状态
|
||
if self.last_update[plc_name][name] > 0:
|
||
self.logger.info(f"PLC {plc_name} area {name} disconnected but keeping last valid data")
|
||
except Exception as e:
|
||
with self.lock:
|
||
self.cache[plc_name][name]["status"] = self.plc_connection_status[plc_name]
|
||
self.logger.warning(f"Error updating status for {plc_name}/{name}: {e}")
|
||
|
||
"""计算刷新一个PLC的时间"""
|
||
# 计算实际执行时间
|
||
execution_time = time.time() - start_time
|
||
#计算需要睡眠的时间，确保总等于refresh_time
|
||
sleep_time = max(0, refresh_interval - execution_time)
|
||
time.sleep(sleep_time)
|
||
|
||
# 记录实际刷新间隔
|
||
self.logger.debug(f"plc_name: {plc_name},"
|
||
f"Cache refresh completed.Execution time: {execution_time:.3f}s,"
|
||
f"Sleep time: {sleep_time:.3f}s,"
|
||
f"Total interval: {execution_time + sleep_time:.3f}s")
|
||
|
||
time.sleep(self.refresh_interval)
|
||
except Exception as e:
|
||
self.logger.error(f"Error in refresh_cache: {e}")
|
||
time.sleep(self.refresh_interval)
|
||
|
||
def start(self):
|
||
"""启动缓存刷新线程"""
|
||
if self.running:
|
||
return
|
||
|
||
self.running = True
|
||
self.thread = threading.Thread(
|
||
target=self.refresh_cache,
|
||
name="CacheRefreshThread",
|
||
daemon=True
|
||
)
|
||
self.thread.start()
|
||
self.logger.info("Cache manager started")
|
||
|
||
def stop(self):
|
||
"""停止缓存刷新线程"""
|
||
if not self.running:
|
||
return
|
||
|
||
self.running = False
|
||
if self.thread:
|
||
# 等待线程结束，但设置超时防止卡死
|
||
self.thread.join(timeout=2.0)
|
||
if self.thread.is_alive():
|
||
self.logger.warning("Cache refresh thread did not terminate gracefully")
|
||
self.thread = None
|
||
self.logger.info("Cache manager stopped")
|
||
|
||
def get_plc_connection_status(self, plc_name):
|
||
"""获取PLC连接状态"""
|
||
with self.lock:
|
||
return self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
def get_last_update_time(self, plc_name, area_name):
|
||
"""获取区域数据最后更新时间"""
|
||
with self.lock:
|
||
return self.last_update.get(plc_name, {}).get(area_name, 0)
|
||
|
||
def get_summary(self):
|
||
"""获取缓存摘要信息"""
|
||
summary = {}
|
||
with self.lock:
|
||
for plc_name, areas in self.cache.items():
|
||
summary[plc_name] = {}
|
||
for area_name, area in areas.items():
|
||
last_update = self.last_update[plc_name][area_name]
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 区域状态应与PLC连接状态一致，除非有有效数据
|
||
area_status = area["status"]
|
||
if plc_status == "never_connected":
|
||
area_status = "never_connected"
|
||
elif plc_status == "disconnected" and self.last_update[plc_name][area_name] == 0:
|
||
area_status = "disconnected"
|
||
|
||
summary[plc_name][area_name] = {
|
||
"status": area_status,
|
||
"plc_connection_status": plc_status,
|
||
"last_update": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(last_update)) if last_update > 0 else "Never",
|
||
"size": area["size"],
|
||
"type": area["type"]
|
||
}
|
||
return summary
|
||
|
||
def get_area_status(self, plc_name, area_name):
|
||
"""获取区域状态"""
|
||
with self.lock:
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
if not area:
|
||
return {"status": "not_found", "message": "PLC or area not found"}
|
||
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
last_update = self.last_update.get(plc_name, {}).get(area_name, 0)
|
||
|
||
# 区域状态应与PLC连接状态一致，除非有有效数据
|
||
area_status = area["status"]
|
||
if plc_status == "never_connected":
|
||
area_status = "never_connected"
|
||
elif plc_status == "disconnected" and last_update == 0:
|
||
area_status = "disconnected"
|
||
|
||
return {
|
||
"status": area_status,
|
||
"plc_connection_status": plc_status,
|
||
"last_update": last_update,
|
||
"last_update_formatted": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(last_update)) if last_update > 0 else "Never",
|
||
"size": area["size"],
|
||
"type": area["type"]
|
||
}
|
||
|
||
def read_area(self, plc_name, area_name, offset, length):
|
||
"""单个区域读取"""
|
||
with self.lock:
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
print("read area :",area)
|
||
if not area:
|
||
return None, "Area not found", "unknown", 0
|
||
|
||
if offset + length > area["size"]:
|
||
return None, "Offset out of bounds", "unknown", 0
|
||
|
||
client = self.plc_manager.get_plc(plc_name)
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
return None, f"PLC not connected (status: {plc_status})", plc_status, 0
|
||
|
||
try:
|
||
data = client.read_db(area["db_number"], area["offset"] + offset, length)
|
||
# 验证数据有效性
|
||
if data and len(data) == length:
|
||
# 更新缓存中的这部分数据
|
||
for i in range(length):
|
||
area["data"][offset + i] = data[i]
|
||
update_time = time.time()
|
||
self.last_update[plc_name][area_name] = update_time
|
||
area["status"] = "connected"
|
||
|
||
return data, None, plc_status, update_time
|
||
else:
|
||
area["status"] = plc_status
|
||
return None, "Invalid data returned", plc_status, 0
|
||
except Exception as e:
|
||
area["status"] = plc_status
|
||
self.logger.error(f"Read failed for {plc_name}/{area_name}: {e}")
|
||
return None, f"Read failed: {str(e)}", plc_status, 0
|
||
|
||
def read_area_bool(self, plc_name, area_name, offset, length):
|
||
"""单个区域读取"""
|
||
with self.lock:
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
if not area:
|
||
return None, "Area not found", "unknown", 0
|
||
|
||
if offset + length > area["size"]:
|
||
return None, "Offset out of bounds", "unknown", 0
|
||
|
||
client = self.plc_manager.get_plc(plc_name)
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
return None, f"PLC not connected (status: {plc_status})", plc_status, 0
|
||
|
||
try:
|
||
data = client.read_db_bool(area["db_number"], area["offset"] + offset, length)
|
||
# 验证数据有效性
|
||
if all(isinstance(val, bool) for val in data.values()):
|
||
# 按字典键顺序更新多个值
|
||
for i, val in data.items():
|
||
area["data"][offset + i] = val # 确保offset+i不越界
|
||
|
||
# area["data"][offset] = data.values
|
||
update_time = time.time()
|
||
self.last_update[plc_name][area_name] = update_time
|
||
area["status"] = "connected"
|
||
|
||
return data, None, plc_status, update_time
|
||
else:
|
||
area["status"] = plc_status
|
||
return None, "Invalid data returned", plc_status, 0
|
||
except Exception as e:
|
||
area["status"] = plc_status
|
||
self.logger.error(f"Read failed for {plc_name}/{area_name}: {e}")
|
||
return None, f"Read failed: {str(e)}", plc_status, 0
|
||
|
||
def write_area(self, plc_name, area_name, offset, data):
|
||
"""单个区域写入"""
|
||
with self.lock:
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
if not area:
|
||
return False, "Area not found", "unknown", 0
|
||
|
||
if area["type"] not in ["write", "read_write"]:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return False, "Area is read-only", plc_status, 0
|
||
|
||
if offset + len(data) > area["size"]:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return False, "Offset out of bounds", plc_status, 0
|
||
|
||
client = self.plc_manager.get_plc(plc_name)
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
return False, f"PLC not connected (status: {plc_status})", plc_status, 0
|
||
|
||
try:
|
||
success = client.write_db(area["db_number"], area["offset"] + offset, data)
|
||
if success:
|
||
# 更新缓存中的这部分数据
|
||
for i in range(len(data)):
|
||
area["data"][offset + i] = data[i]
|
||
update_time = time.time()
|
||
self.last_update[plc_name][area_name] = update_time
|
||
area["status"] = "connected (last write)"
|
||
|
||
return True, None, plc_status, update_time
|
||
else:
|
||
area["status"] = plc_status
|
||
return False, "Write failed", plc_status, 0
|
||
except Exception as e:
|
||
area["status"] = plc_status
|
||
self.logger.error(f"Write failed for {plc_name}/{area_name}: {e}")
|
||
return False, f"Write failed: {str(e)}", plc_status, 0
|
||
|
||
def batch_write_area(self, plc_name, area_name, offset, data):
|
||
"""单个区域写入"""
|
||
with self.lock:
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
if not area:
|
||
return False, "Area not found", "unknown", 0
|
||
|
||
if area["type"] not in ["write", "read_write"]:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return False, "Area is read-only", plc_status, 0
|
||
|
||
if offset + len(data) > area["size"]:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return False, "Offset out of bounds", plc_status, 0
|
||
|
||
client = self.plc_manager.get_plc(plc_name)
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
return False, f"PLC not connected (status: {plc_status})", plc_status, 0
|
||
|
||
try:
|
||
for i, byte in enumerate(data):
|
||
byte_data = bytes([byte])
|
||
current_offset = offset + (i * 2)
|
||
byte_value = byte_data[0]
|
||
|
||
value = bytearray(2)
|
||
if isinstance(byte_value, int):
|
||
set_int(value, 0, byte_value)
|
||
data = value
|
||
|
||
success = client.batch_write_db(area["db_number"], current_offset, data)
|
||
if success:
|
||
# 更新缓存中的这部分数据
|
||
for j in range(len(data)):
|
||
area["data"][offset + j] = data[j]
|
||
update_time = time.time()
|
||
self.last_update[plc_name][area_name] = update_time
|
||
area["status"] = "connected (last write)"
|
||
else:
|
||
area["status"] = plc_status
|
||
return False, "Write failed", plc_status, 0
|
||
return True, None, plc_status, update_time
|
||
except Exception as e:
|
||
area["status"] = plc_status
|
||
self.logger.error(f"Write failed for {plc_name}/{area_name}: {e}")
|
||
return False, f"Write failed: {str(e)}", plc_status, 0
|
||
|
||
def batch_write_bool_area(self, plc_name, area_name, offset, data):
|
||
"""单个区域写入"""
|
||
with self.lock:
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
if not area:
|
||
return False, "Area not found", "unknown", 0
|
||
|
||
if area["type"] not in ["write", "read_write"]:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return False, "Area is read-only", plc_status, 0
|
||
|
||
if offset + len(data) > area["size"]:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return False, "Offset out of bounds", plc_status, 0
|
||
|
||
client = self.plc_manager.get_plc(plc_name)
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
return False, f"PLC not connected (status: {plc_status})", plc_status, 0
|
||
|
||
try:
|
||
value = bytearray(offset + 1)
|
||
for bit, bit_value in enumerate(data):
|
||
set_bool(value, offset, bit, bit_value)
|
||
data = value
|
||
|
||
success = client.batch_write_db_bool(area["db_number"], offset, data)
|
||
if success:
|
||
# 更新缓存中的这部分数据
|
||
for j in range(len(data)):
|
||
area["data"][offset + j] = data[j]
|
||
update_time = time.time()
|
||
self.last_update[plc_name][area_name] = update_time
|
||
area["status"] = "connected (last write)"
|
||
else:
|
||
area["status"] = plc_status
|
||
return False, "Write failed", plc_status, 0
|
||
return True, None, plc_status, update_time
|
||
except Exception as e:
|
||
area["status"] = plc_status
|
||
self.logger.error(f"Write failed for {plc_name}/{area_name}: {e}")
|
||
return False, f"Write failed: {str(e)}", plc_status, 0
|
||
|
||
def write_area_bool(self, plc_name, area_name, offset, data):
|
||
"""单个区域写入"""
|
||
with self.lock:
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
if not area:
|
||
return False, "Area not found", "unknown", 0
|
||
|
||
if area["type"] not in ["write", "read_write"]:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return False, "Area is read-only", plc_status, 0
|
||
|
||
if offset + len(data) > area["size"]:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return False, "Offset out of bounds", plc_status, 0
|
||
|
||
client = self.plc_manager.get_plc(plc_name)
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
return False, f"PLC not connected (status: {plc_status})", plc_status, 0
|
||
|
||
try:
|
||
success = client.write_db_bool(area["db_number"], area["offset"] + offset, data)
|
||
if success:
|
||
# 更新缓存中的这部分数据
|
||
for i in range(len(data)):
|
||
area["data"][offset + i] = data[i]
|
||
update_time = time.time()
|
||
self.last_update[plc_name][area_name] = update_time
|
||
area["status"] = "connected (last write)"
|
||
|
||
return True, None, plc_status, update_time
|
||
else:
|
||
area["status"] = plc_status
|
||
return False, "Write failed", plc_status, 0
|
||
except Exception as e:
|
||
area["status"] = plc_status
|
||
self.logger.error(f"Write failed for {plc_name}/{area_name}: {e}")
|
||
return False, f"Write failed: {str(e)}", plc_status, 0
|
||
|
||
def batch_read(self, requests):
|
||
"""批量读取"""
|
||
results = []
|
||
|
||
for req in requests:
|
||
plc_name = req["plc_name"]
|
||
area_name = req["area_name"]
|
||
offset = req.get("offset", 0)
|
||
length = req.get("length", None)
|
||
|
||
# 获取PLC连接状态
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
results.append({
|
||
"plc_name": plc_name,
|
||
"area_name": area_name,
|
||
"status": "error",
|
||
"plc_connection_status": plc_status,
|
||
"last_update": 0,
|
||
"last_update_formatted": "N/A",
|
||
"message": f"PLC not connected (status: {plc_status})"
|
||
})
|
||
continue
|
||
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
if not area:
|
||
results.append({
|
||
"plc_name": plc_name,
|
||
"area_name": area_name,
|
||
"status": "error",
|
||
"plc_connection_status": plc_status,
|
||
"last_update": 0,
|
||
"last_update_formatted": "N/A",
|
||
"message": "Area not found"
|
||
})
|
||
continue
|
||
|
||
# 如果未指定length，读取整个区域
|
||
if length is None:
|
||
length = area["size"] - offset
|
||
|
||
data, error, _, update_time = self.read_area(plc_name, area_name, offset, length)
|
||
if error:
|
||
results.append({
|
||
"plc_name": plc_name,
|
||
"area_name": area_name,
|
||
"status": "error",
|
||
"plc_connection_status": plc_status,
|
||
"last_update": update_time,
|
||
"last_update_formatted": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(update_time)) if update_time > 0 else "Never",
|
||
"message": error
|
||
})
|
||
else:
|
||
results.append({
|
||
"plc_name": plc_name,
|
||
"area_name": area_name,
|
||
"status": "success",
|
||
"plc_connection_status": plc_status,
|
||
"last_update": update_time,
|
||
"last_update_formatted": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(update_time)),
|
||
"offset": offset,
|
||
"length": length,
|
||
"data": list(data)
|
||
})
|
||
return results
|
||
|
||
def batch_write(self, requests):
|
||
"""批量写入"""
|
||
results = []
|
||
for req in requests:
|
||
plc_name = req["plc_name"]
|
||
area_name = req["area_name"]
|
||
offset = req["offset"]
|
||
data = bytes(req["data"])
|
||
|
||
# 获取PLC连接状态
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
results.append({
|
||
"plc_name": plc_name,
|
||
"area_name": area_name,
|
||
"status": "error",
|
||
"plc_connection_status": plc_status,
|
||
"last_update": 0,
|
||
"last_update_formatted": "N/A",
|
||
"message": f"PLC not connected (status: {plc_status})",
|
||
"offset": offset
|
||
})
|
||
continue
|
||
success, error, _, update_time = self.batch_write_area(plc_name, area_name, offset, data)
|
||
if error:
|
||
results.append({
|
||
"plc_name": plc_name,
|
||
"area_name": area_name,
|
||
"status": "error",
|
||
"plc_connection_status": plc_status,
|
||
"last_update": update_time,
|
||
"last_update_formatted": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(update_time)) if update_time > 0 else "Never",
|
||
"message": error,
|
||
"offset": offset
|
||
})
|
||
else:
|
||
results.append({
|
||
"plc_name": plc_name,
|
||
"area_name": area_name,
|
||
"status": "success",
|
||
"plc_connection_status": plc_status,
|
||
"last_update": update_time,
|
||
"last_update_formatted": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(update_time)),
|
||
"offset": offset,
|
||
"length": len(data)
|
||
})
|
||
return results
|
||
|
||
def batch_write_bool(self, requests):
|
||
"""批量写入"""
|
||
results = []
|
||
for req in requests:
|
||
plc_name = req["plc_name"]
|
||
area_name = req["area_name"]
|
||
offset = req["offset"]
|
||
data = bytes(req["data"])
|
||
|
||
# 获取PLC连接状态
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
results.append({
|
||
"plc_name": plc_name,
|
||
"area_name": area_name,
|
||
"status": "error",
|
||
"plc_connection_status": plc_status,
|
||
"last_update": 0,
|
||
"last_update_formatted": "N/A",
|
||
"message": f"PLC not connected (status: {plc_status})",
|
||
"offset": offset
|
||
})
|
||
continue
|
||
|
||
success, error, _, update_time = self.batch_write_bool_area(plc_name, area_name, offset, data)
|
||
if error:
|
||
results.append({
|
||
"plc_name": plc_name,
|
||
"area_name": area_name,
|
||
"status": "error",
|
||
"plc_connection_status": plc_status,
|
||
"last_update": update_time,
|
||
"last_update_formatted": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(update_time)) if update_time > 0 else "Never",
|
||
"message": error,
|
||
"offset": offset
|
||
})
|
||
else:
|
||
results.append({
|
||
"plc_name": plc_name,
|
||
"area_name": area_name,
|
||
"status": "success",
|
||
"plc_connection_status": plc_status,
|
||
"last_update": update_time,
|
||
"last_update_formatted": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(update_time)),
|
||
"offset": offset,
|
||
"length": len(data)
|
||
})
|
||
return results
|
||
|
||
def read_generic(self, plc_name, area_name, offset, data_type, count=1):
|
||
"""通用读取接口"""
|
||
with self.lock:
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
if not area:
|
||
return None, "Area not found", "unknown", 0
|
||
|
||
if area["type"] not in ["read", "read_write"]:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return None, "Area is read-only", plc_status, 0
|
||
|
||
array_name = f"{plc_name}_{area_name}"
|
||
|
||
# 计算实际DB偏移
|
||
db_offset = area["offset"] + offset
|
||
|
||
# 确保在区域内
|
||
if data_type == 'bool':
|
||
required_size = (offset + count + 7) // 8
|
||
elif data_type in ['int', 'word']:
|
||
required_size = 2 * count
|
||
elif data_type in ['dint', 'dword', 'real']:
|
||
required_size = 4 * count
|
||
else: # byte
|
||
required_size = count
|
||
|
||
if db_offset + required_size > area["size"] or db_offset < 0:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return None, "Offset out of bounds", plc_status, 0
|
||
|
||
client = self.plc_manager.get_plc(plc_name)
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
return None, f"PLC not connected (status: {plc_status})", plc_status, 0
|
||
|
||
try:
|
||
# 使用Snap7Client的read_generic方法
|
||
result = client.read_generic(area["db_number"], db_offset, data_type, array_name, count)
|
||
if result is None:
|
||
return None, "Read failed", plc_status, 0
|
||
|
||
# 对于bool类型，需要特殊处理缓存
|
||
if data_type == 'bool':
|
||
for i in range(count):
|
||
byte_offset = offset // 8 + i // 8
|
||
bit_offset = (offset % 8) + (i % 8)
|
||
if bit_offset >= 8:
|
||
byte_offset += 1
|
||
bit_offset -= 8
|
||
|
||
# 读取当前字节值
|
||
current_byte = area["data"][byte_offset]
|
||
if result[i]:
|
||
# 设置位为1
|
||
new_byte = current_byte | (1 << bit_offset)
|
||
else:
|
||
# 设置位为0
|
||
new_byte = current_byte & ~(1 << bit_offset)
|
||
area["data"][byte_offset] = new_byte
|
||
else:
|
||
# 对于其他类型，直接更新缓存
|
||
if not isinstance(result, list):
|
||
result = [result]
|
||
|
||
if data_type == 'byte':
|
||
item_size = 1
|
||
elif data_type in ['int', 'word']:
|
||
item_size = 2
|
||
else: # dint, dword, real
|
||
item_size = 4
|
||
|
||
for i, val in enumerate(result):
|
||
item_offset = offset + i * item_size
|
||
if data_type == 'byte':
|
||
area["data"][item_offset] = val & 0xFF
|
||
elif data_type in ['int', 'word']:
|
||
# 2字节数据
|
||
packed = struct.pack(">h" if data_type == "int" else ">H", val)
|
||
for j in range(2):
|
||
area["data"][item_offset + j] = packed[j]
|
||
elif data_type in ['dint', 'dword', 'real']:
|
||
# 4字节数据
|
||
packed = struct.pack(
|
||
">l" if data_type == "dint" else
|
||
">I" if data_type == "dword" else
|
||
">f",
|
||
val
|
||
)
|
||
for j in range(4):
|
||
area["data"][item_offset + j] = packed[j]
|
||
|
||
update_time = time.time()
|
||
self.last_update[plc_name][area_name] = update_time
|
||
area["status"] = "connected"
|
||
return result, None, plc_status, update_time
|
||
except Exception as e:
|
||
area["status"] = plc_status
|
||
self.logger.error(f"Read failed for {plc_name}/{area_name}: {e}")
|
||
return None, f"Read failed: {str(e)}", plc_status, 0
|
||
|
||
def write_generic(self, plc_name, area_name, offset, data_type, value):
|
||
"""通用写入接口"""
|
||
with self.lock:
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
if not area:
|
||
return False, "Area not found", "unknown", 0
|
||
|
||
if area["type"] not in ["write", "read_write"]:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return False, "Area is read-only", plc_status, 0
|
||
|
||
# 计算实际DB偏移
|
||
db_offset = area["offset"] + offset
|
||
|
||
# 确保在区域内
|
||
if data_type == 'bool':
|
||
# 确定存储这些布尔值需要多少字节。
|
||
required_size = (offset + (len(value) if isinstance(value, list) else 1) + 7) // 8
|
||
elif data_type in ['int', 'word']:
|
||
required_size = 2 * (len(value) if isinstance(value, list) else 1)
|
||
elif data_type in ['dint', 'dword', 'real']:
|
||
required_size = 4 * (len(value) if isinstance(value, list) else 1)
|
||
else: # byte
|
||
required_size = len(value) if isinstance(value, list) else 1
|
||
|
||
if db_offset + required_size > area["size"] or db_offset < 0:
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
return False, "Offset out of bounds", plc_status, 0
|
||
|
||
client = self.plc_manager.get_plc(plc_name)
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
|
||
# 如果PLC未连接，直接返回错误
|
||
if plc_status != "connected":
|
||
return False, f"PLC not connected (status: {plc_status})", plc_status, 0
|
||
|
||
try:
|
||
# 使用Snap7Client的write_generic方法
|
||
success = client.write_generic(area["db_number"], db_offset, data_type, value)
|
||
if success:
|
||
# 根据数据类型更新缓存
|
||
if data_type == 'bool':
|
||
# 处理bool写入
|
||
if not isinstance(value, list):
|
||
value = [value]
|
||
|
||
for i, val in enumerate(value):
|
||
byte_offset = offset // 8 + i // 8
|
||
bit_offset = (offset % 8) + (i % 8)
|
||
if bit_offset >= 8:
|
||
byte_offset += 1
|
||
bit_offset -= 8
|
||
|
||
# 读取当前字节值
|
||
current_byte = area["data"][byte_offset]
|
||
if val:
|
||
# 设置位为1
|
||
new_byte = current_byte | (1 << bit_offset)
|
||
else:
|
||
# 设置位为0
|
||
new_byte = current_byte & ~(1 << bit_offset)
|
||
area["data"][byte_offset] = new_byte
|
||
elif data_type == 'byte':
|
||
# 处理byte写入
|
||
if not isinstance(value, list):
|
||
value = [value]
|
||
|
||
for i, val in enumerate(value):
|
||
area["data"][offset + i] = val & 0xFF
|
||
elif data_type in ['int', 'word']:
|
||
# 处理int/word写入
|
||
if not isinstance(value, list):
|
||
value = [value]
|
||
|
||
for i, val in enumerate(value):
|
||
# 2字节数据
|
||
packed = struct.pack(">h" if data_type == "int" else ">H", val)
|
||
for j in range(2):
|
||
area["data"][offset + i * 2 + j] = packed[j]
|
||
elif data_type in ['dint', 'dword', 'real']:
|
||
# 处理dint/dword/real写入
|
||
if not isinstance(value, list):
|
||
value = [value]
|
||
|
||
for i, val in enumerate(value):
|
||
# 4字节数据
|
||
packed = struct.pack(
|
||
">l" if data_type == "dint" else
|
||
">I" if data_type == "dword" else
|
||
">f",
|
||
val
|
||
)
|
||
for j in range(4):
|
||
area["data"][offset + i * 4 + j] = packed[j]
|
||
|
||
update_time = time.time()
|
||
self.last_update[plc_name][area_name] = update_time
|
||
area["status"] = "connected (last write)"
|
||
return True, None, plc_status, update_time
|
||
else:
|
||
area["status"] = plc_status
|
||
return False, "Write failed", plc_status, 0
|
||
except Exception as e:
|
||
area["status"] = plc_status
|
||
self.logger.error(f"Write failed for {plc_name}/{area_name}: {e}")
|
||
return False, f"Write failed: {str(e)}", plc_status, 0
|
||
|
||
def get_parsed_data(self, plc_name, area_name):
|
||
"""获取解析后的数据"""
|
||
from data_parser import parse_data
|
||
|
||
with self.lock:
|
||
area = self.cache.get(plc_name, {}).get(area_name)
|
||
if not area:
|
||
return {"error": "Area not found"}
|
||
|
||
plc_status = self.plc_connection_status.get(plc_name, "unknown")
|
||
last_update = self.last_update.get(plc_name, {}).get(area_name, 0)
|
||
|
||
# 区域状态应与PLC连接状态一致，除非有有效数据
|
||
area_status = area["status"]
|
||
if plc_status == "never_connected":
|
||
area_status = "never_connected"
|
||
elif plc_status == "disconnected" and last_update == 0:
|
||
area_status = "disconnected"
|
||
|
||
structure = area.get("structure", [])
|
||
if structure:
|
||
parsed = parse_data(area["data"], structure)
|
||
parsed["status"] = area_status
|
||
parsed["plc_connection_status"] = plc_status
|
||
parsed["last_update"] = last_update
|
||
parsed["last_update_formatted"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(last_update)) if last_update > 0 else "Never"
|
||
return parsed
|
||
else:
|
||
return {
|
||
"raw_data": list(area["data"]),
|
||
"status": area_status,
|
||
"plc_connection_status": plc_status,
|
||
"last_update": last_update,
|
||
"last_update_formatted": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(last_update)) if last_update > 0 else "Never"
|
||
}
|
||
|