DCS_V1.0/model/ProjectModel/BlockManage.py

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()