44 QualifierList = {"N" : False, "R" : False, "S" : False, "L" : True, "D" : True, |
44 QualifierList = {"N" : False, "R" : False, "S" : False, "L" : True, "D" : True, |
45 "P" : False, "P0" : False, "P1" : False, "SD" : True, "DS" : True, "SL" : True} |
45 "P" : False, "P0" : False, "P1" : False, "SD" : True, "DS" : True, "SL" : True} |
46 |
46 |
47 PLCOpenClasses, PLCOpenTypes = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd")) |
47 PLCOpenClasses, PLCOpenTypes = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd")) |
48 |
48 |
49 cls = PLCOpenClasses.get("dataType", None) |
|
50 if cls: |
|
51 cls.value = None |
|
52 |
|
53 def getValue(self): |
|
54 return self.value |
|
55 setattr(cls, "getValue", getValue) |
|
56 |
|
57 def setValue(self, value): |
|
58 self.value = value |
|
59 setattr(cls, "setValue", setValue) |
|
60 |
|
61 def loadXMLTree(self, tree): |
|
62 node = tree.childNodes[1] |
|
63 if node.nodeName == "derived": |
|
64 self.value = PLCOpenClasses["derived"]() |
|
65 self.value.loadXMLTree(node) |
|
66 else: |
|
67 self.value = node.nodeName |
|
68 setattr(cls, "loadXMLTree", loadXMLTree) |
|
69 |
|
70 def generateXMLText(self, name, indent, extras = {}): |
|
71 ind1, ind2 = getIndent(indent, name) |
|
72 text = ind1 + "<%s>\n"%name |
|
73 if isinstance(self.value, (StringType, UnicodeType)): |
|
74 ind3, ind4 = getIndent(indent + 1, self.value) |
|
75 text += ind3 + "<%s/>\n"%self.value |
|
76 else: |
|
77 text += self.value.generateXMLText("derived", indent + 1) |
|
78 text += ind1 + "</%s>\n"%name |
|
79 return text |
|
80 setattr(cls, "generateXMLText", generateXMLText) |
|
81 |
|
82 cls = PLCOpenClasses.get("formattedText", None) |
49 cls = PLCOpenClasses.get("formattedText", None) |
83 if cls: |
50 if cls: |
84 cls.text = "" |
51 cls.text = "" |
85 |
52 |
86 def getText(self): |
53 def getText(self): |
157 setattr(cls, "setName", setName) |
124 setattr(cls, "setName", setName) |
158 |
125 |
159 def getName(self): |
126 def getName(self): |
160 return self.contentHeader.getName() |
127 return self.contentHeader.getName() |
161 setattr(cls, "getName", getName) |
128 setattr(cls, "getName", getName) |
|
129 |
|
130 def getDataTypes(self): |
|
131 return self.types.getDataTypeElements() |
|
132 setattr(cls, "getDataTypes", getDataTypes) |
|
133 |
|
134 def getDataType(self, name): |
|
135 return self.types.getDataTypeElement(name) |
|
136 setattr(cls, "getDataType", getDataType) |
|
137 |
|
138 def appendDataType(self, name): |
|
139 self.types.appendDataTypeElement(name) |
|
140 setattr(cls, "appendDataType", appendDataType) |
|
141 |
|
142 def insertDataType(self, index, datatype): |
|
143 self.types.insertDataTypeElement(index, datatype) |
|
144 setattr(cls, "insertDataType", insertDataType) |
|
145 |
|
146 def removeDataType(self, name): |
|
147 self.types.removeDataTypeElement(name) |
|
148 setattr(cls, "removeDataType", removeDataType) |
162 |
149 |
163 def getPous(self): |
150 def getPous(self): |
164 return self.types.getPouElements() |
151 return self.types.getPouElements() |
165 setattr(cls, "getPous", getPous) |
152 setattr(cls, "getPous", getPous) |
166 |
153 |
291 self.type = new_name |
278 self.type = new_name |
292 setattr(cls, "updateElementName", updateElementName) |
279 setattr(cls, "updateElementName", updateElementName) |
293 |
280 |
294 cls = PLCOpenClasses.get("project_types", None) |
281 cls = PLCOpenClasses.get("project_types", None) |
295 if cls: |
282 if cls: |
|
283 def getDataTypeElements(self): |
|
284 return self.dataTypes.getDataType() |
|
285 setattr(cls, "getDataTypeElements", getDataTypeElements) |
|
286 |
|
287 def getDataTypeElement(self, name): |
|
288 elements = self.dataTypes.getDataType() |
|
289 for element in elements: |
|
290 if element.getName() == name: |
|
291 return element |
|
292 return None |
|
293 setattr(cls, "getDataTypeElement", getDataTypeElement) |
|
294 |
|
295 def appendDataTypeElement(self, name): |
|
296 for element in self.dataTypes.getDataType(): |
|
297 if element.getName() == name: |
|
298 raise ValueError, "\"%s\" Data Type already exists !!!"%name |
|
299 new_datatype = PLCOpenClasses["dataTypes_dataType"]() |
|
300 new_datatype.setName(name) |
|
301 new_datatype.baseType.setContent("BOOL", None) |
|
302 self.dataTypes.appendDataType(new_datatype) |
|
303 setattr(cls, "appendDataTypeElement", appendDataTypeElement) |
|
304 |
|
305 def insertDataTypeElement(self, index, datatype): |
|
306 self.dataTypes.insertDataType(index, datatype) |
|
307 setattr(cls, "insertDataTypeElement", insertDataTypeElement) |
|
308 |
|
309 def removeDataTypeElement(self, name): |
|
310 found = False |
|
311 for idx, element in enumerate(self.dataTypes.getDataType()): |
|
312 if element.getName() == name: |
|
313 self.dataTypes.removeDataType(idx) |
|
314 found = True |
|
315 break |
|
316 if not found: |
|
317 raise ValueError, "\"%s\" Data Type doesn't exist !!!"%name |
|
318 setattr(cls, "removeDataTypeElement", removeDataTypeElement) |
|
319 |
296 def getPouElements(self): |
320 def getPouElements(self): |
297 return self.pous.getPou() |
321 return self.pous.getPou() |
298 setattr(cls, "getPouElements", getPouElements) |
322 setattr(cls, "getPouElements", getPouElements) |
299 |
323 |
300 def getPouElement(self, name): |
324 def getPouElement(self, name): |
438 content = self.interface.getContent() |
462 content = self.interface.getContent() |
439 for varlist in content: |
463 for varlist in content: |
440 variables = varlist["value"].getVariable() |
464 variables = varlist["value"].getVariable() |
441 for var in variables: |
465 for var in variables: |
442 if var.getName() == old_name: |
466 if var.getName() == old_name: |
443 var_type = var.getType().getValue() |
467 vartype_content = var.getType().getContent() |
444 if isinstance(var_type, PLCOpenClasses["derived"]) and var_type.getName() == old_type: |
468 if vartype_content["value"] is not None and vartype_content["value"].getName() == old_type: |
445 var.setName(new_name) |
469 var.setName(new_name) |
446 var.getType().getValue().setName(new_type) |
470 vartype_content["value"].setName(new_type) |
447 return |
471 return |
448 setattr(cls, "changePouVar", changePouVar) |
472 setattr(cls, "changePouVar", changePouVar) |
449 |
473 |
450 def removePouVar(self, type, name): |
474 def removePouVar(self, type, name): |
451 content = self.interface.getContent() |
475 content = self.interface.getContent() |
1413 setattr(cls, "getRelPosition", getRelPosition) |
1437 setattr(cls, "getRelPosition", getRelPosition) |
1414 |
1438 |
1415 cls = PLCOpenClasses.get("value", None) |
1439 cls = PLCOpenClasses.get("value", None) |
1416 if cls: |
1440 if cls: |
1417 def setValue(self, value): |
1441 def setValue(self, value): |
1418 try: |
1442 if value.startswith("[") and value.endswith("]"): |
1419 value = eval(value) |
|
1420 except: |
|
1421 pass |
|
1422 if type(value) == ListType: |
|
1423 arrayValue = PLCOpenClasses["value_arrayValue"]() |
1443 arrayValue = PLCOpenClasses["value_arrayValue"]() |
1424 arrayValue.setValue(value) |
|
1425 self.content = {"name":"arrayValue","value":arrayValue} |
1444 self.content = {"name":"arrayValue","value":arrayValue} |
1426 elif type(value) == DictType: |
1445 elif value.startswith("(") and value.endswith(")"): |
1427 structValue = PLCOpenClasses["value_structValue"]() |
1446 structValue = PLCOpenClasses["value_structValue"]() |
1428 structValue.setValue(value) |
|
1429 self.content = {"name":"structValue","value":structValue} |
1447 self.content = {"name":"structValue","value":structValue} |
1430 else: |
1448 else: |
1431 simpleValue = PLCOpenClasses["value_simpleValue"]() |
1449 simpleValue = PLCOpenClasses["value_simpleValue"]() |
1432 simpleValue.setValue(str(value)) |
|
1433 self.content = {"name":"simpleValue","value":simpleValue} |
1450 self.content = {"name":"simpleValue","value":simpleValue} |
|
1451 self.content["value"].setValue(value) |
1434 setattr(cls, "setValue", setValue) |
1452 setattr(cls, "setValue", setValue) |
1435 |
1453 |
1436 def getValue(self): |
1454 def getValue(self): |
1437 value = self.content["value"].getValue() |
1455 return self.content["value"].getValue() |
1438 try: |
|
1439 value = eval(value) |
|
1440 except: |
|
1441 pass |
|
1442 return value |
|
1443 setattr(cls, "getValue", getValue) |
1456 setattr(cls, "getValue", getValue) |
1444 |
1457 |
1445 cls = PLCOpenClasses.get("value_arrayValue", None) |
1458 cls = PLCOpenClasses.get("value_arrayValue", None) |
1446 if cls: |
1459 if cls: |
1447 def setValue(self, array): |
1460 arrayValue_model = re.compile("([0-9]*)\((.*)\)") |
|
1461 |
|
1462 def setValue(self, value): |
1448 self.value = [] |
1463 self.value = [] |
1449 for value in array: |
1464 for item in value[1:-1].split(","): |
|
1465 item = item.strip() |
1450 element = PLCOpenClasses["arrayValue_value"]() |
1466 element = PLCOpenClasses["arrayValue_value"]() |
1451 element.setValue(value) |
1467 result = arrayValue_model.match(item) |
|
1468 if result is not None: |
|
1469 groups = result.groups() |
|
1470 element.setRepetitionValue(int(groups[0])) |
|
1471 element.setValue(groups[1].strip()) |
|
1472 else: |
|
1473 element.setValue(item) |
1452 self.value.append(element) |
1474 self.value.append(element) |
1453 setattr(cls, "setValue", setValue) |
1475 setattr(cls, "setValue", setValue) |
1454 |
1476 |
1455 def getValue(self): |
1477 def getValue(self): |
1456 return [element.getValue() for element in self.value] |
1478 values = [] |
|
1479 for element in self.value: |
|
1480 repetition = element.getRepetitionValue() |
|
1481 if repetition is not None and repetition > 1: |
|
1482 values.append("%d(%s)"%(repetition, element.getValue())) |
|
1483 else: |
|
1484 values.append(element.getValue()) |
|
1485 return "[%s]"%", ".join(values) |
1457 setattr(cls, "getValue", getValue) |
1486 setattr(cls, "getValue", getValue) |
1458 |
1487 |
1459 cls = PLCOpenClasses.get("value_structValue", None) |
1488 cls = PLCOpenClasses.get("value_structValue", None) |
1460 if cls: |
1489 if cls: |
1461 def setValue(self, dict): |
1490 structValue_model = re.compile("(.*):=(.*)") |
|
1491 |
|
1492 def setValue(self, value): |
1462 self.value = [] |
1493 self.value = [] |
1463 for name,value in dict.items(): |
1494 for item in value[1:-1].split(","): |
1464 element = PLCOpenClasses["structValue_value"]() |
1495 result = arrayValue_model.match(item) |
1465 element.setMember(name) |
1496 if result is not None: |
1466 element.setValue(value) |
1497 groups = result.groups() |
|
1498 element = PLCOpenClasses["structValue_value"]() |
|
1499 element.setMember(groups[0].strip()) |
|
1500 element.setValue(groups[1].strip()) |
1467 self.value.append(element) |
1501 self.value.append(element) |
1468 setattr(cls, "setValue", setValue) |
1502 setattr(cls, "setValue", setValue) |
1469 |
1503 |
1470 def getValue(self): |
1504 def getValue(self): |
1471 value = {} |
1505 values = [] |
1472 for element in self.value: |
1506 for element in self.value: |
1473 value[element.getMember()] = element.getValue() |
1507 values.append("%s := %s"%(element.getMember(), element.getValue())) |
1474 return value |
1508 return "(%s)"%", ".join(values) |
1475 setattr(cls, "getValue", getValue) |
1509 setattr(cls, "getValue", getValue) |