0620更新

UI/BlockParameterModel.py

@@ -10,6 +10,7 @@ from PyQt5.QtWidgets import QItemDelegate, QHBoxLayout, QWidget, QPushButton, QM
 from UI.LoadingDataWidget import LoadingDataWidget
 from UI.ObjectTypeEditlayout import ObjectTypeEditlayout
 
+from utils import Globals
 
 class VarTableModel(QAbstractTableModel):
     ''' 变量表模型类'''
@@ -203,14 +204,16 @@ class VarButtonDelegate(QItemDelegate):
         sender = self.sender()
         blockView = self.parent()
         model = blockView.model
-        blockName = blockView.blockType
-        blcokIndex = blockView.blcokIndex
-        print(modelIndex)
+        blockType = blockView.blockType
+        blockIndex = blockView.blcokIndex
+
+        blockManage = Globals.getValue('blockManage')
+
         if modelIndex or str(modelIndex) == '0' :
             value = modelIndex
 
         else:
-            index = model.datas[sender.index[0]][0]
+            parmIndex = model.datas[sender.index[0]][0]
             values = objectTypeEditlayout.getEditlineValue()
             if not values:
                 reply = QMessageBox.question(self.parent(),
@@ -228,21 +231,24 @@ class VarButtonDelegate(QItemDelegate):
                                                 "请输入强制值或数字",
                                                 QMessageBox.Yes)
                     return
+            res = blockManage.writeParmValue(blockType, blockIndex, parmIndex, values)
      
     
     def refreshData(self, modelIndex = None):
         sender = self.sender()
         blockView = self.parent()
         model = blockView.model
-        index = model.datas[sender.index[0]][0]
-        blockName = blockView.blockType
-        blcokIndex = blockView.blcokIndex
+        parmIndex = model.datas[sender.index[0]][0]
+        blockType = blockView.blockType
+        blockIndex = blockView.blcokIndex
         
         # print(blockName, blcokIndex, index)
-
-        self.loadingDataWidget = LoadingDataWidget()
-        self.loadingDataWidget.loadData()
-        model.updateColumn(sender.index[0],'sss')
+        blockManage = Globals.getValue('blockManage')
+        value = blockManage.getBlockParmValue(blockType, blockIndex, parmIndex)
+        # self.loadingDataWidget = LoadingDataWidget()
+        # self.loadingDataWidget.show()
+        # self.loadingDataWidget.loadData(1, 1)
+        model.updateColumn(sender.index[0], value)
         # self.parent().resizeHeader()
         blockView.proxy.invalidate()
 

UI/ObjectTypeEditlayout.py

@@ -45,7 +45,7 @@ class ObjectTypeEditlayout(QVBoxLayout):
         if self.dataType == 'DS-50':
             self.editline1.setPlaceholderText('仿真转换块值状况')
             self.editline2.setPlaceholderText('仿真转换块值')
-            self.editline3.setPlaceholderText('启用或者警用仿真转换块(0:禁用, <>0:启用)')
+            self.editline3.setPlaceholderText('启用或者禁用仿真转换块(0:禁用, <>0:启用)')
 
             self.addWidget(self.editline1)
             self.addWidget(self.editline2)

model/ProjectModel/BlockManage.py

@@ -24,7 +24,7 @@ class LoadDataThread(QThread):
  
     def run(self):
         valueList = []
-        for index, parm in enumerate(self.parent.parms):
+        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)
@@ -115,6 +115,21 @@ class BlockManage():
         # print(self.blockDict)
 
     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)]
+        result = parm.writeParm(values)
+        return result
+
+    def resetBlockType(self, blockType, blockIndex):
         if not isinstance(blockType, BlockType):
             typ = BlockType.TB
             block = self.blockDict[typ][blockIndex]
@@ -122,7 +137,7 @@ class BlockManage():
             block.addParms()
         else:
             block = self.blockDict[blockType][blockIndex]
-        return block.getParmsValue(callback, callback2)
+        return block
 
     def getBlockNums(self):
         return [len(self.blockDict[BlockType.PB]), len(self.blockDict[BlockType.TB]), len(self.blockDict[BlockType.FB])]
@@ -140,13 +155,13 @@ class Block():
     address = None
     loadDataSignal = pyqtSignal(int, int)
     def __init__(self, blockType, DPV1Master):
-        self.parms = []
+        self.parms = {}
         self.blockType = blockType
         self.DPV1Master = DPV1Master
         # self.addParms()
     
     def addParms(self):
-        self.parms = []
+        self.parms = {}
         getParmsFunc = {
             BlockType.PB: PhysicalBlock.getallParame,
             BlockType.TB: PressureTranslationBlock.getallParame,
@@ -162,7 +177,8 @@ class Block():
             # print(parmData)
             # print(self.startIndex, 3214)
             parm = Parm(parmData, self.slot, self.startIndex, self)
-            self.parms.append(parm)
+            self.parms[parm.relativeIndex] = parm
+            # self.parms.append(parm)
 
     def getParmsValue(self, callback, callback2):
         valueList = []
@@ -175,6 +191,9 @@ class Block():
         # print(valueList)
         # return valueList
 
+    def getParmValue(self, index, callback, callback2):
+        return
+
     def getTBType(self):
         return
 

model/ProjectModel/ParmManage.py

@@ -34,9 +34,13 @@ class Parm():
         if value == '读取错误':
             return '读取错误'
         else:
-            return self.analysisValue(value)
+            return self.unpackValue(value)
+
+    def writeParm(self, values):
+        valueByte = self.packValue(*values)
+        result = self.DPV1Master.writeParm(address = self.address, slot = self.slot, index = self.realIndex, length = self.size, valueByte = valueByte)
     
-    def analysisValue(self, value):
+    def unpackValue(self, value):
         match self.dataType:
             case 'Unsigned8':
                 return self.unpackU8(value)
@@ -60,9 +64,36 @@ class Parm():
                 return self.unpackDS50(value)
             case 'OctetString' | 'VisibleString':
                 return self.unpackStr(value)
+            case 'FloatList2':
+                return self.unpackFloatList2(value)
             case _:
                 return str(value)
 
+    def packValue(self, values):
+        match self.dataType:
+            case 'Unsigned8':
+                return self.packU8(values)
+            case 'Unsigned16':
+                return self.packU16(values)
+            case 'Unsigned32':
+                return self.packU32(values)
+            case 'Float':
+                return self.packFloat(values)
+            case '101':
+                return self.pack101(values)
+            case 'DS-32':
+                return self.packDS32(values)
+            case 'DS-36':
+                return self.packDS36(values)
+            case 'DS-50':
+                return self.packDS50(values)
+            case 'OctetString' | 'VisibleString':
+                return self.packStr(values)
+            case 'FloatList2':
+                return self.packFloatList2(values)
+            case _:
+                return 
+
     def unpackU8(self, value):
         return str(struct.unpack('>b', value)[0])
 
@@ -114,7 +145,7 @@ class Parm():
 
     def unpackDS37(self, value):
         actualByte, permitByte, normalByte = value[0].to_bytes(1, byteorder='little'), value[1].to_bytes(1, byteorder='little'), value[2].to_bytes(1, byteorder='little')
-        print(type(actualByte), permitByte, normalByte)
+        # print(type(actualByte), permitByte, normalByte)
         actualMode = self.unpackU8(actualByte)
         permitMode = self.unpackU8(permitByte)
         normalMode = self.unpackU8(normalByte)
@@ -140,14 +171,25 @@ class Parm():
         displayStr = '仿真值状态:{}\r\n仿真值:{}\r\n是否启用仿真:{}'
         return displayStr
 
+    def unpackFloatList2(self, value):
+        float1Byte, float2Byte = value[:4], value[4:8]
+        float1 = self.unpackFloat(float1Byte)
+        float2 = self.unpackFloat(float2Byte)
+        displayStr = '值1:{}\r\n值2:{}'.format(float1, float2)
+        return displayStr
+
+
     def packU8(self, value):
-        return struct.pack('>b', value)
+        return struct.pack('>b', int(value))
 
     def packU16(self, value):
-        return struct.pack('>h', value)
+        return struct.pack('>h', int(value))
 
     def packFloat(self, value):
-        return struct.pack('>f', value)
+        return struct.pack('>f', float(value))
+
+    def packU32(self, value):
+        return struct.pack('>i', int(value))
 
     def pack101(self, value, status):
         valueByte = self.packFloat(value)
@@ -163,6 +205,7 @@ class Parm():
         packedData = EU100Byte + EU0Byte + unitByte + decPointByte
         return packedData
 
+
     def packDS50(self, simulateStatus, simulateValue, simulateEnabled):
 	    simulateStatusByte = self.packU8(simulateStatus)
 	    simulateValueByte = self.packFloat(simulateValue)
@@ -170,6 +213,12 @@ class Parm():
 	    packedData = simulateStatusByte + simulateValueByte + simulateEnabledByte
 	    return packedData
 
+    def packFloatList2(self, float1, float2):
+        float1Byte = self.packFloat(float1)
+        float2Byte = self.packFloat(float2)
+        packedData = float1Byte + float2Byte
+        return packedData
+
     def unitConver(self, unitValue):
         unit, desc = '1', '1'
-        return unit + desc
+        return unit + desc

protocol/ModBus/DPV1Master.py

@@ -74,9 +74,9 @@ class DPV1Master():
         slotByte = slot.to_bytes(1, byteorder='little')
         indexByte = index.to_bytes(1, byteorder='little')
         readByteStream = b'\x01' + hexAddress + slotByte + indexByte + b'\xF0\x00'
-        searchDate = struct.unpack('>hhh', readByteStream)
+        readDate = struct.unpack('>hhh', readByteStream)
         self.writeMultipleRegister(1, 750, self.resetData)
-        self.writeMultipleRegister(1, 750, searchDate)
+        self.writeMultipleRegister(1, 750, readDate)
         time.sleep(0.3)
         value = self.readHoldingRegisters(1, 750, -(-length // 2)) #  -(-length // 2)向上取整
         if value[0] == 57344:
@@ -88,11 +88,33 @@ class DPV1Master():
         # print(value)
         self.writeMultipleRegister(1, 750, self.resetData)
         time.sleep(0.1)
-        if callable(callback):
-            callback(value)
-            return
+        # if callable(callback):
+        #     callback(value)
+        #     return
         return value
 
+    def writeParm(self, address, slot, index, length, valueByte):
+        length = int(length)
+        hexAddress = address.to_bytes(1, byteorder='little')
+        slotByte = slot.to_bytes(1, byteorder='little')
+        indexByte = index.to_bytes(1, byteorder='little')
+        lengthByte = length.to_bytes(1, byteorder='little')
+        writeByteStream = b'\x02' + hexAddress + slotByte + indexByte + lengthByte + valueByte
+        writeByteStream  = writeByteStream if len(writeByteStream) % 2 == 0 else writeByteStream + b'\x00'
+        self.writeMultipleRegister(1, 750, self.resetData)
+        print(len(writeByteStream))
+        writeDate = struct.unpack('>{}h'.format(len(writeByteStream)  // 2), writeByteStream)
+        self.writeMultipleRegister(1, 750, writeDate)
+        time.sleep(0.3)
+        value = self.readHoldingRegisters(1, 750, 2)
+        if value[0] == 57344:
+            result = '写入错误'
+        else:
+            result = '写入成功'
+        self.writeMultipleRegister(1, 750, self.resetData)
+        time.sleep(0.1)
+        return result
+
     def judgeSlave(self, address):
         hexAddress = address.to_bytes(1, byteorder='little')
         searchByteStream = b'\x01' + hexAddress + b'\x01\x00\xF0\x00'