plcopeneditor_history: comparison plcopen/plcopen.py

equal deleted inserted replaced

-:fd138fc77510
+:3a1b0afdaf84
 #You should have received a copy of the GNU General Public
 #License along with this library; if not, write to the Free Software
 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 from xmlclass import *
+from types import *
 import os, sys
 """
 Dictionary that makes the relation between var names in plcopen and displayed values
 """
 if os.path.isfile(os.path.join(path, "plcopen/TC6_XML_V10_B.xsd")):
 base_folder = path
 GenerateClassesFromXSD(os.path.join(base_folder, "plcopen/TC6_XML_V10_B.xsd"))
 CreateClasses(PLCOpenClasses, PLCOpenTypes)
-if "dataType" in PLCOpenClasses:
+cls = PLCOpenClasses.get("dataType", None)
-cls = PLCOpenClasses["dataType"]
+if cls:
 cls.value = None
 def getValue(self):
 return self.value
 setattr(cls, "getValue", getValue)
 def setValue(self, value):
 self.value = value
 setattr(cls, "setValue", setValue)
 def loadXMLTree(self, tree):
-self.value = tree.childNodes[1].nodeName
+node = tree.childNodes[1]
+if node.nodeName == "derived":
+self.value = PLCOpenClasses["derived"]()
+self.value.loadXMLTree(node)
+else:
+self.value = node.nodeName
 setattr(cls, "loadXMLTree", loadXMLTree)
 def generateXMLText(self, name, indent, extras = {}):
 ind1, ind2 = getIndent(indent, name)
 text = ind1 + "<%s>\n"%name
-ind3, ind4 = getIndent(indent + 1, self.value)
+if isinstance(self.value, (StringType, UnicodeType)):
-text += ind3 + "<%s/>\n"%self.value
+ind3, ind4 = getIndent(indent + 1, self.value)
+text += ind3 + "<%s/>\n"%self.value
+else:
+text += self.value.generateXMLText("derived", indent + 1)
 text += ind1 + "</%s>\n"%name
 return text
 setattr(cls, "generateXMLText", generateXMLText)
-if "formattedText" in PLCOpenClasses:
+cls = PLCOpenClasses.get("formattedText", None)
-cls = PLCOpenClasses["formattedText"]
+if cls:
 cls.text = ""
 def getText(self):
 return self.text
 setattr(cls, "getText", getText)
 setattr(cls, "loadXMLTree", loadXMLTree)
 def generateXMLText(self, name, indent, extras = {}):
 ind1, ind2 = getIndent(indent, name)
 if len(self.text.splitlines()) > 1:
-text = ind1 + "<%s>\n"%name
+text = ind1 + "<%s>\n<![CDATA[\n"%name
 text += "%s\n"%self.text
-text += ind1 + "</%s>\n"%name
+text += "]]>\n" + ind1 + "</%s>\n"%name
 return text
 else:
-return ind1 + "<%s>%s</%s>\n"%(name, self.text, name)
+return ind1 + "<%s><![CDATA[%s]]></%s>\n"%(name, self.text, name)
 setattr(cls, "generateXMLText", generateXMLText)
 def updateElementName(self, old_name, new_name):
 index = self.text.find(old_name)
 while index != -1:
 else:
 self.text = self.text[:index] + new_name + self.text[index + len(old_name):]
 index = self.text.find(old_name, index + len(new_name))
 setattr(cls, "updateElementName", updateElementName)
-if "project" in PLCOpenClasses:
+cls = PLCOpenClasses.get("project", None)
-cls = PLCOpenClasses["project"]
+if cls:
 cls.singleLineAttributes = False
 def getFileHeader(self):
 fileheader = {}
 fileheader["companyName"] = self.fileHeader.getCompanyName()
 pou.updateElementName(old_name, new_name)
 for configuration in self.instances.configurations.getConfiguration():
 configuration.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-PLCOpenClasses["project_fileHeader"].singleLineAttributes = False
+cls = PLCOpenClasses.get("project_fileHeader", None)
+if cls:
-if "configurations_configuration" in PLCOpenClasses:
+cls.singleLineAttributes = False
-cls = PLCOpenClasses["configurations_configuration"]
+cls = PLCOpenClasses.get("configurations_configuration", None)
+if cls:
 def updateElementName(self, old_name, new_name):
 for resource in self.getResource():
 resource.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-if "configuration_resource" in PLCOpenClasses:
+cls = PLCOpenClasses.get("configuration_resource", None)
-cls = PLCOpenClasses["configuration_resource"]
+if cls:
 def updateElementName(self, old_name, new_name):
 for instance in self.getPouInstance():
 instance.updateElementName(old_name, new_name)
 for task in self.getTask():
 task.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-if "resource_task" in PLCOpenClasses:
+cls = PLCOpenClasses.get("resource_task", None)
-cls = PLCOpenClasses["resource_task"]
+if cls:
 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)
-if "pouInstance" in PLCOpenClasses:
+cls = PLCOpenClasses.get("pouInstance", None)
-cls = PLCOpenClasses["pouInstance"]
+if cls:
 def updateElementName(self, old_name, new_name):
 if self.type == old_name:
 self.type = new_name
 setattr(cls, "updateElementName", updateElementName)
-if "project_types" in PLCOpenClasses:
+cls = PLCOpenClasses.get("project_types", None)
-cls = PLCOpenClasses["project_types"]
+if cls:
 def getPouElements(self):
 return self.pous.getPou()
 setattr(cls, "getPouElements", getPouElements)
 def getPouElement(self, name):
 def getText(self):
 return self.body.getText()
 setattr(cls, "getText", getText)
-if "pous_pou" in PLCOpenClasses:
+cls = PLCOpenClasses.get("pous_pou", None)
-cls = PLCOpenClasses["pous_pou"]
+if cls:
 setattr(cls, "setBodyType", setBodyType)
 setattr(cls, "getBodyType", getBodyType)
 setattr(cls, "addInstance", addInstance)
 setattr(cls, "getInstances", getInstances)
 setattr(cls, "getInstance", getInstance)
 self.interface.setContent([])
 for vartype, varlist in vars:
 self.interface.appendContent(VarTypes[vartype], varlist)
 setattr(cls, "setVars", setVars)
+def addPouVar(self, type, name):
+content = self.interface.getContent()
+if len(content) == 0 or content[-1]["name"] != "localVars":
+self.interface.appendContent("localVars", PLCOpenClasses["varList"]())
+var = PLCOpenClasses["varListPlain_variable"]()
+var.setName(name)
+var_type = PLCOpenClasses["dataType"]()
+derived_type = PLCOpenClasses["derived"]()
+derived_type.setName(type)
+var_type.setValue(derived_type)
+var.setType(var_type)
+content[-1]["value"].appendVariable(var)
+setattr(cls, "addPouVar", addPouVar)
+def removePouVar(self, type, name):
+content = self.interface.getContent()
+for varlist in content:
+variables = varlist["value"].getVariable()
+for var in variables:
+if var.getName() == name:
+var_type = var.getType().getValue()
+if isinstance(var_type, PLCOpenClasses["derived"]) and var_type.getName() == type:
+variables.remove(var)
+break
+if len(varlist["value"].getVariable()) == 0:
+content.remove(varlist)
+break
+setattr(cls, "removePouVar", removePouVar)
 def addTransition(self, name, type):
 if not self.transitions:
 self.addTransitions()
 self.transitions.setTransition([])
 transition = PLCOpenClasses["transitions_transition"]()
 action.updateElementName(old_name, new_name)
 for transition in self.getTransitionList():
 transition.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-if "transitions_transition" in PLCOpenClasses:
+cls = PLCOpenClasses.get("transitions_transition", None)
-cls = PLCOpenClasses["transitions_transition"]
+if cls:
 setattr(cls, "setBodyType", setBodyType)
 setattr(cls, "getBodyType", getBodyType)
 setattr(cls, "addInstance", addInstance)
 setattr(cls, "getInstances", getInstances)
 setattr(cls, "getInstance", getInstance)
 def updateElementName(self, old_name, new_name):
 self.body.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-if "actions_action" in PLCOpenClasses:
+cls = PLCOpenClasses.get("actions_action", None)
-cls = PLCOpenClasses["actions_action"]
+if cls:
 setattr(cls, "setBodyType", setBodyType)
 setattr(cls, "getBodyType", getBodyType)
 setattr(cls, "addInstance", addInstance)
 setattr(cls, "getInstances", getInstances)
 setattr(cls, "getInstance", getInstance)
 def updateElementName(self, old_name, new_name):
 self.body.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-if "body" in PLCOpenClasses:
+cls = PLCOpenClasses.get("body", None)
-cls = PLCOpenClasses["body"]
+if cls:
 def appendContentInstance(self, name, instance):
 if self.content["name"] in ["LD","FBD","SFC"]:
 self.content["value"].appendContent(name, instance)
 else:
 raise TypeError, "%s body don't have instances!"%self.content["name"]
 self.position.setX(x)
 def setY(self, y):
 self.position.setY(y)
-if "comment" in PLCOpenClasses:
+cls = PLCOpenClasses.get("comment", None)
-cls = PLCOpenClasses["comment"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 self.content.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-if "block" in PLCOpenClasses:
+cls = PLCOpenClasses.get("block", None)
-cls = PLCOpenClasses["block"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 if self.typeName == old_name:
 self.typeName = new_name
 setattr(cls, "updateElementName", updateElementName)
-if "inputVariables_variable" in PLCOpenClasses:
+cls = PLCOpenClasses.get("inputVariables_variable", None)
-cls = PLCOpenClasses["inputVariables_variable"]
+if cls:
 def setConnectorEdge(self, edge):
 if not self.edge:
 self.edge = PLCOpenClasses["edgeModifierType"]()
 self.edge.setValue(edge)
 setattr(cls, "setConnectorEdge", setConnectorEdge)
 if self.edge:
 return self.edge.getValue()
 return None
 setattr(cls, "getConnectorEdge", getConnectorEdge)
-if "outputVariables_variable" in PLCOpenClasses:
+cls = PLCOpenClasses.get("outputVariables_variable", None)
-cls = PLCOpenClasses["outputVariables_variable"]
+if cls:
 def setConnectorEdge(self, edge):
 if not self.edge:
 self.edge = PLCOpenClasses["edgeModifierType"]()
 self.edge.setValue(edge)
 setattr(cls, "setConnectorEdge", setConnectorEdge)
 if self.edge:
 return self.edge.getValue()
 return None
 setattr(cls, "getConnectorEdge", getConnectorEdge)
-if "leftPowerRail" in PLCOpenClasses:
+cls = PLCOpenClasses.get("leftPowerRail", None)
-cls = PLCOpenClasses["leftPowerRail"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-if "contact" in PLCOpenClasses:
+cls = PLCOpenClasses.get("rightPowerRail", None)
-cls = PLCOpenClasses["contact"]
+if cls:
+setattr(cls, "getX", getX)
+setattr(cls, "getY", getY)
+setattr(cls, "setX", setX)
+setattr(cls, "setY", setY)
+def updateElementName(self, old_name, new_name):
+pass
+setattr(cls, "updateElementName", updateElementName)
+cls = PLCOpenClasses.get("contact", None)
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 if self.variable == old_name:
 self.variable = new_name
 setattr(cls, "updateElementName", updateElementName)
-if "coil" in PLCOpenClasses:
+cls = PLCOpenClasses.get("coil", None)
-cls = PLCOpenClasses["coil"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 if self.variable == old_name:
 self.variable = new_name
 setattr(cls, "updateElementName", updateElementName)
-if "rightPowerRail" in PLCOpenClasses:
+cls = PLCOpenClasses.get("step", None)
-cls = PLCOpenClasses["rightPowerRail"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-if "step" in PLCOpenClasses:
+cls = PLCOpenClasses.get("transition", None)
-cls = PLCOpenClasses["step"]
+if cls:
-setattr(cls, "getX", getX)
-setattr(cls, "getY", getY)
-setattr(cls, "setX", setX)
-setattr(cls, "setY", setY)
-def updateElementName(self, old_name, new_name):
-pass
-setattr(cls, "updateElementName", updateElementName)
-if "transition" in PLCOpenClasses:
-cls = PLCOpenClasses["transition"]
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 return None
 setattr(cls, "getConnectionParameter", getConnectionParameter)
 setattr(cls, "addConnection", addConnection)
-if "selectionDivergence" in PLCOpenClasses:
+cls = PLCOpenClasses.get("selectionDivergence", None)
-cls = PLCOpenClasses["selectionDivergence"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-if "selectionConvergence" in PLCOpenClasses:
+cls = PLCOpenClasses.get("selectionConvergence", None)
-cls = PLCOpenClasses["selectionConvergence"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-if "simultaneousDivergence" in PLCOpenClasses:
+cls = PLCOpenClasses.get("simultaneousDivergence", None)
-cls = PLCOpenClasses["simultaneousDivergence"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-if "simultaneousDivergence" in PLCOpenClasses:
+cls = PLCOpenClasses.get("simultaneousConvergence", None)
-cls = PLCOpenClasses["simultaneousConvergence"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-if "jumpStep" in PLCOpenClasses:
+cls = PLCOpenClasses.get("jumpStep", None)
-cls = PLCOpenClasses["jumpStep"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
+cls = PLCOpenClasses.get("actionBlock_action", None)
-if "actionBlock_action" in PLCOpenClasses:
+if cls:
-cls = PLCOpenClasses["actionBlock_action"]
 def setQualifierValue(self, value):
 if self.qualifier:
 self.qualifier.setValue(value)
 setattr(cls, "setQualifierValue", setQualifierValue)
 self.reference.setName(new_name)
 if self.inline:
 self.inline.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-if "actionBlock" in PLCOpenClasses:
+cls = PLCOpenClasses.get("actionBlock", None)
-cls = PLCOpenClasses["actionBlock"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 for action in self.action:
 action.updateElementName(old_name, new_name)
 setattr(cls, "updateElementName", updateElementName)
-if "inVariable" in PLCOpenClasses:
+cls = PLCOpenClasses.get("inVariable", None)
-cls = PLCOpenClasses["inVariable"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 if self.expression == old_name:
 self.expression = new_name
 setattr(cls, "updateElementName", updateElementName)
-if "outVariable" in PLCOpenClasses:
+cls = PLCOpenClasses.get("outVariable", None)
-cls = PLCOpenClasses["outVariable"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 if self.expression == old_name:
 self.expression = new_name
 setattr(cls, "updateElementName", updateElementName)
-if "inOutVariable" in PLCOpenClasses:
+cls = PLCOpenClasses.get("inOutVariable", None)
-cls = PLCOpenClasses["inOutVariable"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 if self.expression == old_name:
 self.expression = new_name
 setattr(cls, "updateElementName", updateElementName)
-if "continuation" in PLCOpenClasses:
+cls = PLCOpenClasses.get("continuation", None)
-cls = PLCOpenClasses["continuation"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-if "connector" in PLCOpenClasses:
+cls = PLCOpenClasses.get("connector", None)
-cls = PLCOpenClasses["connector"]
+if cls:
 setattr(cls, "getX", getX)
 setattr(cls, "getY", getY)
 setattr(cls, "setX", setX)
 setattr(cls, "setY", setY)
 def updateElementName(self, old_name, new_name):
 pass
 setattr(cls, "updateElementName", updateElementName)
-if "connection" in PLCOpenClasses:
+cls = PLCOpenClasses.get("connection", None)
-cls = PLCOpenClasses["connection"]
+if cls:
 def setPoints(self, points):
 self.position = []
 for point in points:
 position = PLCOpenClasses["position"]()
 position.setX(point.x)
 for position in self.position:
 points.append((position.getX(),position.getY()))
 return points
 setattr(cls, "getPoints", getPoints)
-if "connectionPointIn" in PLCOpenClasses:
+cls = PLCOpenClasses.get("connectionPointIn", None)
-cls = PLCOpenClasses["connectionPointIn"]
+if cls:
 def setRelPosition(self, x, y):
 self.relPosition = PLCOpenClasses["position"]()
 self.relPosition.setX(x)
 self.relPosition.setY(y)
 setattr(cls, "setRelPosition", setRelPosition)
 if self.content:
 return self.content["value"][idx].getFormalParameter()
 return None
 setattr(cls, "getConnectionParameter", getConnectionParameter)
-if "connectionPointOut" in PLCOpenClasses:
+cls = PLCOpenClasses.get("connectionPointOut", None)
-cls = PLCOpenClasses["connectionPointOut"]
+if cls:
 def setRelPosition(self, x, y):
 self.relPosition = PLCOpenClasses["position"]()
 self.relPosition.setX(x)
 self.relPosition.setY(y)
 setattr(cls, "setRelPosition", setRelPosition)
 if self.relPosition:
 return self.relPosition.getX(), self.relPosition.getY()
 return self.relPosition
 setattr(cls, "getRelPosition", getRelPosition)
-if "value" in PLCOpenClasses:
+cls = PLCOpenClasses.get("value", None)
-cls = PLCOpenClasses["value"]
+if cls:
 def setValue(self, value):
 try:
 value = eval(value)
 except:
 pass
 except:
 pass
 return value
 setattr(cls, "getValue", getValue)
-if "value_arrayValue" in PLCOpenClasses:
+cls = PLCOpenClasses.get("value_arrayValue", None)
-cls = PLCOpenClasses["value_arrayValue"]
+if cls:
 def setValue(self, array):
 self.value = []
 for value in array:
 element = PLCOpenClasses["arrayValue_value"]()
 element.setValue(value)
 def getValue(self):
 return [element.getValue() for element in self.value]
 setattr(cls, "getValue", getValue)
-if "value_structValue" in PLCOpenClasses:
+cls = PLCOpenClasses.get("value_structValue", None)
-cls = PLCOpenClasses["value_structValue"]
+if cls:
 def setValue(self, dict):
 self.value = []
 for name,value in dict.items():
 element = PLCOpenClasses["structValue_value"]()
 element.setMember(name)

changeset 67	3a1b0afdaf84
parent 63	04a02b4b2a57
child 68	66308e07402c