plcopeneditor_history: comparison plcopen/plcopen.py

equal deleted inserted replaced

-:7ea1f5094df3
+:6a72016d721a
 if self.y_min is not None and self.y_max is not None:
 height = self.y_max - self.y_min
 return self.x_min, self.y_min, width, height
-PLCOpenClasses = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd"))
+PLCOpenClasses = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd"))
 ElementNameToClass = {}
 cls = PLCOpenClasses.get("formattedText", None)
 if cls:
 task.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 cls = PLCOpenClasses.get("resource_task", None)
 if cls:
+def compatibility(self, tree):
+if tree.hasAttribute("interval"):
+interval = GetAttributeValue(tree._attrs["interval"])
+result = time_model.match(interval)
+if result is not None:
+values = result.groups()
+time_values = [int(v) for v in values[:2]]
+seconds = float(values[2])
+time_values.extend([int(seconds), int((seconds % 1) * 1000000)])
+text = "t#"
+if time_values[0] != 0:
+text += "%dh"%time_values[0]
+if time_values[1] != 0:
+text += "%dm"%time_values[1]
+if time_values[2] != 0:
+text += "%ds"%time_values[2]
+if time_values[3] != 0:
+if time_values[3] % 1000 != 0:
+text += "%.3fms"%(float(time_values[3]) / 1000)
+else:
+text += "%dms"%(time_values[3] / 1000)
+NodeSetAttr(tree, "interval", text)
+setattr(cls, "compatibility", compatibility)
 def updateElementName(self, old_name, new_name):
 if self.single == old_name:
 self.single = new_name
 for instance in self.getpouInstance():
 instance.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
 cls = PLCOpenClasses.get("pouInstance", None)
 if cls:
+def compatibility(self, tree):
+if tree.hasAttribute("type"):
+NodeRenameAttr(tree, "type", "typeName")
+setattr(cls, "compatibility", compatibility)
 def updateElementName(self, old_name, new_name):
 if self.type == old_name:
 self.type = new_name
 setattr(cls, "updateElementName", updateElementName)
 if element.getname() == name:
 raise ValueError, "\"%s\" POU already exists !!!"%name
 new_pou = PLCOpenClasses["pous_pou"]()
 new_pou.setname(name)
 new_pou.setpouType(pou_type)
-new_pou.setbody(PLCOpenClasses["body"]())
+new_pou.appendbody(PLCOpenClasses["body"]())
 new_pou.setbodyType(body_type)
 self.pous.appendpou(new_pou)
 setattr(cls, "appendpouElement", appendpouElement)
 def insertpouElement(self, index, pou):
 break
 if not found:
 raise ValueError, "\"%s\" POU doesn't exist !!!"%name
 setattr(cls, "removepouElement", removepouElement)
-def setbodyType(self, type):
-if type == "IL":
-self.body.setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})
-elif type == "ST":
-self.body.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
-elif type == "LD":
-self.body.setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})
-elif type == "FBD":
-self.body.setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})
-elif type == "SFC":
-self.body.setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})
-else:
-raise ValueError, "%s isn't a valid body type!"%type
-def getbodyType(self):
-return self.body.getcontent()["name"]
-def resetexecutionOrder(self):
-self.body.resetexecutionOrder()
-def compileexecutionOrder(self):
-self.body.compileexecutionOrder()
-def setelementExecutionOrder(self, instance, new_executionOrder):
-self.body.setelementExecutionOrder(instance, new_executionOrder)
-def addinstance(self, name, instance):
-self.body.appendcontentInstance(name, instance)
-def getinstances(self):
-return self.body.getcontentInstances()
-def getinstance(self, id):
-return self.body.getcontentInstance(id)
-def getrandomInstance(self, exclude):
-return self.body.getcontentRandomInstance(exclude)
-def getinstanceByName(self, name):
-return self.body.getcontentInstanceByName(name)
-def removeinstance(self, id):
-self.body.removecontentInstance(id)
-def settext(self, text):
-self.body.settext(text)
-def gettext(self):
-return self.body.gettext()
-setattr(cls, "gettext", gettext)
 cls = PLCOpenClasses.get("pous_pou", None)
 if cls:
+def setbodyType(self, type):
+if len(self.body) > 0:
+if type == "IL":
+self.body[0].setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})
+elif type == "ST":
+self.body[0].setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
+elif type == "LD":
+self.body[0].setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})
+elif type == "FBD":
+self.body[0].setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})
+elif type == "SFC":
+self.body[0].setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})
+else:
+raise ValueError, "%s isn't a valid body type!"%type
 setattr(cls, "setbodyType", setbodyType)
+def getbodyType(self):
+if len(self.body) > 0:
+return self.body[0].getcontent()["name"]
 setattr(cls, "getbodyType", getbodyType)
+def resetexecutionOrder(self):
+if len(self.body) > 0:
+self.body[0].resetexecutionOrder()
 setattr(cls, "resetexecutionOrder", resetexecutionOrder)
+def compileexecutionOrder(self):
+if len(self.body) > 0:
+self.body[0].compileexecutionOrder()
 setattr(cls, "compileexecutionOrder", compileexecutionOrder)
+def setelementExecutionOrder(self, instance, new_executionOrder):
+if len(self.body) > 0:
+self.body[0].setelementExecutionOrder(instance, new_executionOrder)
 setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)
+def addinstance(self, name, instance):
+if len(self.body) > 0:
+self.body[0].appendcontentInstance(name, instance)
 setattr(cls, "addinstance", addinstance)
+def getinstances(self):
+if len(self.body) > 0:
+return self.body[0].getcontentInstances()
+return []
 setattr(cls, "getinstances", getinstances)
+def getinstance(self, id):
+if len(self.body) > 0:
+return self.body[0].getcontentInstance(id)
+return None
 setattr(cls, "getinstance", getinstance)
+def getrandomInstance(self, exclude):
+if len(self.body) > 0:
+return self.body[0].getcontentRandomInstance(exclude)
+return None
 setattr(cls, "getrandomInstance", getrandomInstance)
+def getinstanceByName(self, name):
+if len(self.body) > 0:
+return self.body[0].getcontentInstanceByName(name)
+return None
 setattr(cls, "getinstanceByName", getinstanceByName)
+def removeinstance(self, id):
+if len(self.body) > 0:
+self.body[0].removecontentInstance(id)
 setattr(cls, "removeinstance", removeinstance)
+def settext(self, text):
+if len(self.body) > 0:
+self.body[0].settext(text)
 setattr(cls, "settext", settext)
+def gettext(self):
+if len(self.body) > 0:
+return self.body[0].gettext()
+return ""
 setattr(cls, "gettext", gettext)
 def getvars(self):
 vars = []
 if self.interface is not None:
 action.updateElementName(old_name, new_name)
 for transition in self.gettransitionList():
 transition.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
+def setbodyType(self, type):
+if type == "IL":
+self.body.setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})
+elif type == "ST":
+self.body.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
+elif type == "LD":
+self.body.setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})
+elif type == "FBD":
+self.body.setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})
+elif type == "SFC":
+self.body.setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})
+else:
+raise ValueError, "%s isn't a valid body type!"%type
+def getbodyType(self):
+return self.body.getcontent()["name"]
+def resetexecutionOrder(self):
+self.body.resetexecutionOrder()
+def compileexecutionOrder(self):
+self.body.compileexecutionOrder()
+def setelementExecutionOrder(self, instance, new_executionOrder):
+self.body.setelementExecutionOrder(instance, new_executionOrder)
+def addinstance(self, name, instance):
+self.body.appendcontentInstance(name, instance)
+def getinstances(self):
+return self.body.getcontentInstances()
+def getinstance(self, id):
+return self.body.getcontentInstance(id)
+def getrandomInstance(self, exclude):
+return self.body.getcontentRandomInstance(exclude)
+def getinstanceByName(self, name):
+return self.body.getcontentInstanceByName(name)
+def removeinstance(self, id):
+self.body.removecontentInstance(id)
+def settext(self, text):
+self.body.settext(text)
+def gettext(self):
+return self.body.gettext()
 cls = PLCOpenClasses.get("transitions_transition", None)
 if cls:
 setattr(cls, "setbodyType", setbodyType)
 setattr(cls, "getbodyType", getbodyType)
 setattr(cls, "resetexecutionOrder", resetexecutionOrder)
 if self.connectionPointOutAction:
 specific_values["action"] = _getconnectioninfos(self, self.connectionPointOutAction)
 return infos
 setattr(cls, "getinfos", getinfos)
+cls = PLCOpenClasses.get("transition_condition", None)
+if cls:
+def compatibility(self, tree):
+connections = []
+for child in tree.childNodes:
+if child.nodeName == "connection":
+connections.append(child)
+if len(connections) > 0:
+node = CreateNode("connectionPointIn")
+relPosition = CreateNode("relPosition")
+NodeSetAttr(relPosition, "x", "0")
+NodeSetAttr(relPosition, "y", "0")
+node.childNodes.append(relPosition)
+node.childNodes.extend(connections)
+tree.childNodes = [node]
+setattr(cls, "compatibility", compatibility)
 cls = _initElementClass("transition", "sfcObjects_transition", "single")
 if cls:
 def getinfos(self):
 infos = _getelementinfos(self)
 infos["type"] = "transition"
 priority = 0
 specific_values["priority"] = priority
 condition = self.getconditionContent()
 specific_values["condition_type"] = condition["type"]
 if specific_values["condition_type"] == "connection":
+specific_values["connection"] = _getconnectioninfos(self, condition["value"], True)
-specific_values["connection"] = _getconnectioninfos(self, self, True)
 else:
 specific_values["condition"] = condition["value"]
 infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True))
 infos["outputs"].append(_getconnectioninfos(self, self.connectionPointOut))
 return infos
 elif type == "inline":
 condition = PLCOpenClasses["condition_inline"]()
 condition.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
 condition.settext(value)
 elif type == "connection":
-condition = [PLCOpenClasses["connection"]()]
+type = "connectionPointIn"
+condition = PLCOpenClasses["connectionPointIn"]()
 self.condition.setcontent({"name" : type, "value" : condition})
 setattr(cls, "setconditionContent", setconditionContent)
 def getconditionContent(self):
 if self.condition:
 values = {"type" : content["name"]}
 if values["type"] == "reference":
 values["value"] = content["value"].getname()
 elif values["type"] == "inline":
 values["value"] = content["value"].gettext()
+elif values["type"] == "connectionPointIn":
+values["type"] = "connection"
+values["value"] = content["value"]
 return values
 return ""
 setattr(cls, "getconditionContent", getconditionContent)
 def updateElementName(self, old_name, new_name):
 content["value"].setname(new_name)
 elif content["name"] == "inline":
 content["value"].updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-def setrelPositionXY(self, x, y):
-pass
-setattr(cls, "setrelPositionXY", setrelPositionXY)
-def getrelPositionXY(self):
-return None
-setattr(cls, "getrelPositionXY", getrelPositionXY)
-def addconnection(self):
-if self.condition:
-content = self.condition.getcontent()
-if content["name"] != "connection":
-self.condition.setcontent({"name" : "connection", "value" : [PLCOpenClasses["connection"]()]})
-content = self.condition.getcontent()
-else:
-content["value"].append(PLCOpenClasses["connection"]())
-setattr(cls, "addconnection", addconnection)
-def removeconnection(self, idx):
-if self.condition:
-content = self.condition.getcontent()
-if content["name"] == "connection":
-content["value"].pop(idx)
-setattr(cls, "removeconnection", removeconnection)
-def removeconnections(self):
-if self.condition:
-content = self.condition.getcontent()
-if content["name"] == "connection":
-content["value"] = [PLCOpenClasses["connection"]()]
-setattr(cls, "removeconnections", removeconnections)
 def getconnections(self):
 if self.condition:
 content = self.condition.getcontent()
-if content["name"] == "connection":
+if content["name"] == "connectionPointIn":
-return content["value"]
+return content["value"].getconnections()
 setattr(cls, "getconnections", getconnections)
-def setconnectionId(self, idx, id):
-if self.condition:
-content = self.condition.getcontent()
-if content["name"] == "connection":
-content["value"][idx].setrefLocalId(id)
-setattr(cls, "setconnectionId", setconnectionId)
-def getconnectionId(self, idx):
-if self.condition:
-content = self.condition.getcontent()
-if content["name"] == "connection":
-return content["value"][idx].getrefLocalId()
-return None
-setattr(cls, "getconnectionId", getconnectionId)
-def setconnectionPoints(self, idx, points):
-if self.condition:
-content = self.condition.getcontent()
-if content["name"] == "connection":
-content["value"][idx].setpoints(points)
-setattr(cls, "setconnectionPoints", setconnectionPoints)
-def getconnectionPoints(self, idx):
-if self.condition:
-content = self.condition.getcontent()
-if content["name"] == "connection":
-return content["value"][idx].getpoints()
-return None
-setattr(cls, "getconnectionPoints", getconnectionPoints)
-def setconnectionParameter(self, idx, parameter):
-if self.condition:
-content = self.condition.getcontent()
-if content["name"] == "connection":
-content["value"][idx].setformalParameter(parameter)
-setattr(cls, "setconnectionParameter", setconnectionParameter)
-def getconnectionParameter(self, idx):
-if self.condition:
-content = self.condition.getcontent()
-if content["name"] == "connection":
-content["value"][idx].getformalParameter()
-return None
-setattr(cls, "getconnectionParameter", getconnectionParameter)
 cls = _initElementClass("selectionDivergence", "sfcObjects_selectionDivergence", "single")
 if cls:
 setattr(cls, "getinfos", _getdivergenceinfosFunction(True, False))
 return infos
 setattr(cls, "getinfos", getinfos)
 cls = PLCOpenClasses.get("actionBlock_action", None)
 if cls:
+def compatibility(self, tree):
+relPosition = reduce(lambda x, y: x | (y.nodeName == "relPosition"), tree.childNodes, False)
+if not tree.hasAttribute("localId"):
+NodeSetAttr(tree, "localId", "0")
+if not relPosition:
+node = CreateNode("relPosition")
+NodeSetAttr(node, "x", "0")
+NodeSetAttr(node, "y", "0")
+tree.childNodes.insert(0, node)
+setattr(cls, "compatibility", compatibility)
 def setreferenceName(self, name):
 if self.reference:
 self.reference.setname(name)
 setattr(cls, "setreferenceName", setreferenceName)
 item = item.strip()
 element = PLCOpenClasses["arrayValue_value"]()
 result = arrayValue_model.match(item)
 if result is not None:
 groups = result.groups()
-element.setrepetitionValue(int(groups[0]))
+element.setrepetitionValue(groups[0])
 element.setvalue(groups[1].strip())
 else:
 element.setvalue(item)
 self.value.append(element)
 setattr(cls, "setvalue", setvalue)
 def getvalue(self):
 values = []
 for element in self.value:
 repetition = element.getrepetitionValue()
 if repetition is not None and repetition > 1:
-values.append("%d(%s)"%(repetition, element.getvalue()))
+values.append("%s(%s)"%(repetition, element.getvalue()))
 else:
 values.append(element.getvalue())
 return "[%s]"%", ".join(values)
 setattr(cls, "getvalue", getvalue)

changeset 389	6a72016d721a
parent 387	fcae4e40f296
child 391	07447ee3538e