import sys sys.path.append('../../') import struct from enum import Enum from utils.DBModels.DeviceParModels import * from protocol.ModBus.DPV1Master import DPV1Master from model.ProjectModel.ParmManage import Parm import concurrent.futures import threading from PyQt5.QtCore import pyqtSignal, pyqtSlot, QThread class LoadDataThread(QThread): loadDataSignal = pyqtSignal(int, int) finished = pyqtSignal(list) def __init__(self, parent): super().__init__() self.parent = parent def run(self): valueList = [] for index, parm in enumerate(self.parent.parms.values()): self.loadDataSignal.emit(len(self.parent.parms), index + 1) valueList.append(parm.readValue()) self.finished.emit(valueList) class BlockType(Enum): TB = 1 PB = 0 FB = 2 class TBType(Enum): flowTB = -1 tempTB = -2 levelTB = -3 # 物位转换块 pressureTB = -4 wikaLevelTB = -5 kfFlowTB = -6 class BlockManage(): _instance = None _dpv1MasterPA = None _dpv1MasterDP = None # def __new__(cls, address): # if not cls._instance: # cls._instance = super().__new__(cls) # return cls._instance def __init__(self, _isPa, address = None): # print(_isPa) self._isPa = _isPa self.address = address self.TBTypeList = [] if address: # pass self.initBlocks() @property def DPV1Master(self): if not self._dpv1MasterPA or not self._dpv1MasterDP: self._dpv1MasterPA = DPV1Master('192.168.3.10', 502) self._dpv1MasterDP = DPV1Master('192.168.1.10', 502) if self._isPa: return self._dpv1MasterPA else: return self._dpv1MasterDP def initBlocks(self): # print(self._isPa,5555) if not self.DPV1Master.judgeSlave(self.address): # print(self.address) raise RuntimeError(f"连接从站{self.address}失败.") self.blockDict = { BlockType.PB : [], BlockType.TB : [], BlockType.FB : [], } self.TBTypeList = [] dirHeadDatas = self.DPV1Master.readParm(address = self.address, slot = 1, index = 0, length = 12) dirHeadDatas = struct.unpack('>6h', dirHeadDatas) DirID = dirHeadDatas[0] # 目录id DirRevNum = dirHeadDatas[1] # 目录版本号 NumDirObj = dirHeadDatas[2] # 目录对象的个数 (如果整个目录使用多于一个目录对象， # 则这此元素被连续定义，就如同使用一个较大的对象。 # 多个目录对象都被连续地列在该目录中。该对象计数整个目录所需的对象。Header对象不计人其) NumDirEntry = dirHeadDatas[3] # 目录登录项的总数 (应计算复合列表目录登录项和复合目录登录项的总个数；实际块数量为NumDirEntry - 3) FirstCompListDirEntry = dirHeadDatas[4] # 第1个复合列表目录登录项的目录登录项个数 (该数用来计数目录内的登录项， 而不包含该登 # 录项的参数地址。第1 个目录登录项是在复合列表目录登录项中的物理块引用。在计数登录 # 项时，复合列表目录登录项与复合目录登录项之间无间隔) NumCompListDirEntry = dirHeadDatas[5] # 功能块类型数量 复合列表目录登录项的个数 计数设备内的不同块类型(物理块、转换块和功能块)和对象类型 #（在本标准范围内仅针对链接对象） dirLength = 4 * NumCompListDirEntry dirDatas = self.DPV1Master.readParm(address = self.address, slot = 1, index = 1, length = dirLength) dirDatas = struct.unpack('>{}h'.format(int(dirLength/2)), dirDatas) entryTuples = [(dirDatas[i], dirDatas[i+1]) for i in range(0, len(dirDatas), 2)] # print(entryTuples) dirMesDic = {} for dirMes in entryTuples: blockIndex = struct.pack('>h', dirMes[0])[0] blockNums = dirMes[1] # print(blockIndex) if blockIndex in dirMesDic: dirMesDic[blockIndex] = dirMesDic[blockIndex] + blockNums else: dirMesDic[blockIndex] = blockNums # print(dirMesDic) # entryTuples = [] for key, value in dirMesDic.items(): # print(key, value) if key == 1: entryTuples = [] data = self.DPV1Master.readParm(address = self.address, slot = 1, index = 1, length = dirLength + 4 * value) else: data = self.DPV1Master.readParm(address = self.address, slot = 1, index = key, length = 4 * value) # print(data, int(len(data)/2)) # print(data) data = struct.unpack('>{}h'.format(int(len(data)/2)), data) # print(data) tuples = [(data[i], data[i+1]) for i in range(0, len(data), 2)] entryTuples += tuples # print(entryTuples) for typ in [BlockType.PB, BlockType.TB, BlockType.FB]: # print(typ) typeIndex = typ.value if type(typ.value) == int else 1 blkDirMesByte = struct.pack('>h', entryTuples[typeIndex][0]) blkIndex = int(blkDirMesByte[0]) # 目录对象编号 blkoffect = int(blkDirMesByte[1]) # 块从第几个Dir_Entry开始 # print(blkoffect) numBlk = entryTuples[typeIndex][1] # 块数量 # print(blkIndex, blkoffect, numBlk) for i in range(numBlk): blkEntryListIndex = blkoffect - 1 + i # print(blkEntryListIndex, entryTuples) blkPointerByte = struct.pack('>h', entryTuples[blkEntryListIndex][0]) numBlkParms = entryTuples[blkEntryListIndex][1] blkSlot = int(blkPointerByte[0]) blkStartIndex = int(blkPointerByte[1]) # print(111, blkStartIndex, ) block = Block(typ, self.DPV1Master) block.slot = blkSlot block.startIndex = blkStartIndex block.numParms = numBlkParms block.blockIndex = i block.address = self.address block.addParms() # print(block.startIndex, block.slot) if typ == BlockType.TB: self.TBTypeList.append(block.getTBType()) self.blockDict[typ].append(block) # print(blkSlot, blkIndex) # print(self.blockDict) # print(self.TBTypeList) def getBlockValues(self, blockType, blockIndex, callback, callback2): block = self.resetBlockType(blockType, blockIndex) return block.getParmsValue(callback, callback2) def getBlockParmValue(self, blockType, blockIndex, parmIndex): block = self.resetBlockType(blockType, blockIndex) parm = block.parms[int(parmIndex)] return parm.readValue() def writeParmValue(self, blockType, blockIndex, parmIndex, values): block = self.resetBlockType(blockType, blockIndex) parm = block.parms[int(parmIndex)] # print(values) result = parm.writeParm(values) return result def resetBlockType(self, blockType, blockIndex): if not isinstance(blockType, BlockType): typ = BlockType.TB block = self.blockDict[typ][blockIndex] block.blockType = blockType block.addParms() else: block = self.blockDict[blockType][blockIndex] return block def getBlockNums(self): # return [1,1,1] return [len(self.blockDict[BlockType.PB]), len(self.blockDict[BlockType.TB]), len(self.blockDict[BlockType.FB])] # def getTBTypes(self): @classmethod def searchSlave(self, callback): self.DPV1Master.searchSlave(callback) class Block(): slot = None startIndex = None numParms = None blockIndex = None address = None loadDataSignal = pyqtSignal(int, int) def __init__(self, blockType, DPV1Master): self.parms = {} self.blockType = blockType self.DPV1Master = DPV1Master # self.addParms() def addParms(self): self.parms = {} getParmsFunc = { BlockType.PB: PhysicalBlock.getallParame, BlockType.TB: PressureTranslationBlock.getallParame, BlockType.FB: AIFunctionBlock.getallParame, TBType.flowTB: FlowTranslationBlock.getallParame, TBType.pressureTB: PressureTranslationBlock.getallParame, TBType.tempTB: TemperatureTranslationBlock.getallParame, TBType.levelTB: LevelTranslationBlock.getallParame, TBType.wikaLevelTB: WiKaLevelTranslationBlock.getallParame, TBType.kfFlowTB: KaiFengFlowTranslationBlock.getallParame }.get(self.blockType, lambda: []) parmsData = getParmsFunc() for parmData in parmsData: # print(parmData) # print(self.startIndex, 3214) parm = Parm(parmData, self.slot, self.startIndex, self) self.parms[parm.relativeIndex] = parm # self.parms.append(parm) def getParmsValue(self, callback, callback2): valueList = [] # self.loadDataSignal.connect(callback.loadData) self.thread = LoadDataThread(self) self.thread.loadDataSignal.connect(callback) self.thread.start() self.thread.finished.connect(callback2) # thread.join() # print(valueList) # return valueList def getParmValue(self, index, callback, callback2): return def getTBType(self): value = int(self.parms[list(self.parms.keys())[0]].readValue()) # print(value, type(value)) match value: case 1: return TBType.pressureTB case 2: return TBType.tempTB case 3: return TBType.flowTB case 4: return TBType.levelTB def getParmIndex(self, blockType, paramName): match blockType: case "BlockType.PB": PhysicalBlock.getIndex(paramName) case "BlockType.FB": AIFunctionBlock.getIndex(paramName) case "BlockType.TB": pass if __name__ == '__main__': b = BlockManage(address = 55) c = BlockManage(address = 77) # b.initBlock()