0615更新

model/ProjectModel/BlockManage.py

@@ -3,15 +3,18 @@ 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
 
 class BlockType(Enum):
+    class TB(Enum):
+        phyTB = -1
+        tempTB = -2
+        levelTB = -3 # 物位转换块
+        pressureTB = -4
     PB = 0
-    TB = 1
-    FB = 2
+    FB = 1
 
 class BlockManage():
     _instance = None
@@ -23,20 +26,18 @@ class BlockManage():
         return cls._instance
 
     def __init__(self, address = 66):
-        self.DPV1Master = DPV1Master('192.168.3.10', 502)
         self.address = address
-        print(self.address, self)
         self.initBlocks()
 
     @property
     def DPV1Master(self):
-        if not _dpv1Master:
+        if not self._dpv1Master:
             self._dpv1Master = DPV1Master('192.168.3.10', 502)
         return self._dpv1Master
     
     def initBlocks(self):
         if not self.DPV1Master.judgeSlave(self.address):
-            return
+            raise RuntimeError(f"连接从站{self.address}失败.")
         self.blockDict = {
         BlockType.PB : [],
         BlockType.TB : [],
@@ -73,13 +74,19 @@ class BlockManage():
                 blkSlot = int(blkPointerByte[0])
                 blkStartIndex = int(blkPointerByte[1])
 
-                block = Block(typ)
+                block = Block(typ, self.DPV1Master)
                 block.slot = blkSlot
-                block.startAddress = blkStartIndex
+                block.startIndex = blkStartIndex
                 block.numParms = numBlkParms
-                self.blockDict[typ].append(block) 
+                block.blockIndex = i
+                block.address = self.address
+                if not block.getTBType():
+                self.blockDict[typ].append(block)
                 # print(blkSlot, blkIndex)
-        print(self.blockDict)
+        # print(self.blockDict)
+
+    def getBlockValues(slef, blockType, blockIndex):
+        pass
 
 
 
@@ -89,20 +96,33 @@ class Block():
     slot = None
     startIndex = None
     numParms = None
-    def __init__(self, blockType):
+    blockIndex = None
+    address = None
+    def __init__(self, blockType, DPV1Master):
         self.parms = []
         self.blockType = blockType
         self.addParms()
+        self.DPV1Master = DPV1Master
     
     def addParms(self):
-        # pass
         getParmsFunc = {
             BlockType.PB: PhysicalBlock.getallParame,
             BlockType.TB: AIFunctionBlock.getallParame,
             BlockType.FB: PressureTranslationBlock.getallParame,
         }.get(self.blockType, lambda: [])
         
-        parms_data = getParmsFunc()
+        parmsData = getParmsFunc()
+        for parmData in parmsData:
+            parm = Parm(parmData, self.slot, self.startIndex, self.DPV1Master)
+
+    def getTBType(self):
+        return
+
+    def setTBType(self):
+
+
+
+
 
 
 

model/ProjectModel/ParmManage.py

@@ -1,12 +1,144 @@
+from enum import Enum
+import struct
+import time
+
+class ParmEnum(Enum):
+    readonly = 0
+    writeable = 1
 
 
 class Parm():
     name = None
-    value = None
+    value = '读取错误'
     slot = None
-    index = None
-    type = None
+    relativeIndex = None
+    realIndex = None
+    dataType = None
     size = None
     desc = None
-    def __init__(self):
-        pass
+    rdType = None
+    def __init__(self, parmData:list, slot:int, startIndex:int, block):
+        self.relativeIndex, self.paramName, self.desc, self.dataType, rdStr, self.size, *rest = parmData
+        self.rdType = ParmEnum.readonly if rdStr == 'r' else ParmEnum.writeable
+        self.realIndex = startIndex + self.relativeIndex
+        self.slot = slot
+        self.DPV1Master = block.DPV1Master
+        self.address = block.address
+        # print(self.relativeIndex, self.paramName, self.desc, self.dataType, self.rdType, self.size)
+
+    def readValue(self):
+        value = self.DPV1Master.readParm(address = self.address, slot = self.slot, index = self.realIndex, length = self.size)
+        if value == '读取错误':
+            return
+        else:
+            self.analysisValue(value)
+    
+    def analysisValue(self, value):
+        pass
+
+    def unpackU8(self, value):
+    	return str(struct.unpack('>b', value))
+
+    def unpackU16(self, value):
+    	return str(struct.unpack('>h', value))
+
+    def unpackFloat(self, value):
+    	return str(struct.unpack('>f', value))
+
+    def unpackStr(self, value):
+    	return struct.unpack('{}s'.format{str(len(value))}, value)
+
+    def unpack101(self, value):
+    	valueByte, statusByte = value[:4], value[4]
+    	value = self.unpackFloat(valueByte)
+    	status = self.unpackU8(statusByte)
+    	displayStr = '值:{} 状态:{}'.format(value, status)
+    	return displayStr
+
+    def unpackDS32(self, value):
+    	reserved = self.unpackU8(value[0:1])
+        blockObject = self.unpackU8(value[1:2])
+        parentClass = self.unpackU8(value[2:3])
+        clas = self.unpackU8(value[3:4])
+        devRev = self.unpackU16(value[4:6])
+        devRevComp = self.unpackU16(value[6:8])
+        ddRevision = self.unpackStr(value[8:10])
+        profile = self.unpackStr(value[10:12])
+        profileRevision = self.unpackU16(value[12:14])
+        executionTime = self.unpackU8(value[14:15])
+        numberOfParameters = self.unpackU16(value[15:17])
+        addressOfView1 = self.unpackU16(value[17:19])
+        numberOfViews = self.unpackU8(value[19:20])
+        return
+
+
+    def unpackDS36(self, value):
+    	EU100Byte, EU0Byte, unitByte, decPointByte = value[:4], value[4:], value[8:10], value[10]
+    	EU100 = self.unpackFloat(EU100Byte)
+    	EU0 = self.unpackFloat(EU0Byte)
+    	decPoint = self.unpackU8(decPointByte)
+    	unitValue = self.unpackU16(unitByte)
+    	unit = self.unitConver(unitValue)
+    	displayStr = '有效上限:{} 有效下限:{} 单位:{} 小数点:{}'.format(EU100, EU0, unit, decPoint)
+    	return displayStr
+
+    def unpackDS37(self, value):
+    	actualByte, permitByte, normalByte = value[0], value[1], value[2]
+    	actualMode = self.unpackU8(actualByte)
+    	permitMode = self.unpackU8(permitByte)
+    	normalMode = self.unpackU8(normalByte)
+    	displayStr = '实际模式:{} 允许模式:{} 正常模式:{}'.format(actualMode, permitMode, normalMode)
+    	return displayStr
+
+    def unpackDS39(self, value):
+    	unacknowledgByte, alarmStateByte, timeStampByte, subcodeByte, alarmValueByte = value[0], value[1], value[2:10], value[10:12], value[12:16]
+    	unacknowledg = self.unpackU8(unacknowledgByte)
+    	alarmState = self.unpackU8(alarmStateByte)
+    	subcode = self.unpackU16(subcodeByte)
+    	alarmValue = self.unpackFloat(alarmValueByte)
+    	timestamp = int.from_bytes(timeStampByte, byteorder='big')
+    	timeStr = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(timestamp))
+    	displayStr = 'Unacknowledged:{} 有无报警{} 时间戳:{} 报警原因:{} 引起报警的值:{}'.format(unacknowledg, alarmState, timeStr, subcode, alarmValue)
+    	return displayStr
+
+    def unpackDS50(self, value):
+    	simulateStatusByte, simulateValueByte, simulateEnabledByte = value[0], value[1:5], value[5]
+    	simulateStatus = self.unpackU8(simulateStatusByte)
+    	simulateValue = self.unpackFloat(simulateValueByte)
+    	simulateEnabled = self.unpackU8(simulateEnabledByte)
+    	displayStr = '仿真值状态:{} 仿真值:{} 是否启用仿真:{}'
+    	return displayStr
+
+    def packU8(self, value):
+    	return struct.pack('>b', value)
+
+    def packU16(self, value):
+    	return struct.pack('>h', value)
+
+    def packFloat(self, value):
+    	return struct.pack('>f', value)
+
+    def pack101(self, value, status):
+		valueByte = self.packFloat(value)
+		statusByte = self.packU8(status)
+		packedData = valueByte + statusByte
+		return packedData
+
+    def packDS36(self, EU100, EU0, unitValue, decPoint):
+		EU100Byte = self.packFloat(EU100)
+		EU0Byte = self.packFloat(EU0)
+		unitByte = self.packU16(unitValue)
+		decPointByte = self.packU8(decPoint)
+		packedData = EU100Byte + EU0Byte + unitByte + decPointByte
+		return packedData
+
+	def packDS50(self, simulateStatus, simulateValue, simulateEnabled):
+	    simulateStatusByte = self.packU8(simulateStatus)
+	    simulateValueByte = self.packFloat(simulateValue)
+	    simulateEnabledByte = self.packU8(simulateEnabled)
+	    packedData = simulateStatusByte + simulateValueByte + simulateEnabledByte
+	    return packedData
+
+    def unitConver(self, unitValue):
+    	unit, desc = '1', '1'
+    	return unit + desc

protocol/ModBus/DPV1Master.py

@@ -56,7 +56,7 @@ class DPV1Master():
             value = self.master.execute(slaveId, cst.READ_HOLDING_REGISTERS, startAddress, varNums)
             return value
         except:
-            return 'error'
+            return '读取错误'
     
     def areAllZeros(self, tup):
         return all(x == 0 for x in tup)
@@ -78,6 +78,7 @@ class DPV1Master():
         self.writeMultipleRegister(1, 750, searchDate)
         time.sleep(0.3)
         value = self.readHoldingRegisters(1, 750, -(-length // 2)) #  -(-length // 2)向上取整
+        value = struct.pack('>{}b'.format(-(-length // 2)), value)[:length]
         self.writeMultipleRegister(1, 750, self.resetData)
         time.sleep(0.1)
         if callable(callback):