diff -r 7ea1f5094df3 -r 6a72016d721a plcopen/plcopen.py --- a/plcopen/plcopen.py Fri Jul 24 11:55:46 2009 +0200 +++ b/plcopen/plcopen.py Fri Jul 24 12:29:48 2009 +0200 @@ -89,7 +89,7 @@ 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 = {} @@ -703,6 +703,30 @@ 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 @@ -712,6 +736,11 @@ 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 @@ -772,7 +801,7 @@ 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) @@ -792,71 +821,88 @@ 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): @@ -1042,6 +1088,56 @@ 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) @@ -1635,6 +1731,23 @@ 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): @@ -1648,8 +1761,7 @@ condition = self.getconditionContent() specific_values["condition_type"] = condition["type"] if specific_values["condition_type"] == "connection": - - specific_values["connection"] = _getconnectioninfos(self, self, True) + specific_values["connection"] = _getconnectioninfos(self, condition["value"], True) else: specific_values["condition"] = condition["value"] infos["inputs"].append(_getconnectioninfos(self, self.connectionPointIn, True)) @@ -1668,7 +1780,8 @@ 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) @@ -1680,6 +1793,9 @@ 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) @@ -1694,89 +1810,12 @@ 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": - return content["value"] + if content["name"] == "connectionPointIn": + 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: @@ -1806,6 +1845,17 @@ 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) @@ -2082,7 +2132,7 @@ 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) @@ -2094,7 +2144,7 @@ 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)