diff -r f7832baaad84 -r aaa80b48bead PLCControler.py --- a/PLCControler.py Tue Jan 22 10:53:34 2008 +0100 +++ b/PLCControler.py Tue Jan 22 10:57:41 2008 +0100 @@ -22,7 +22,6 @@ #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 minixsv import pyxsval from xml.dom import minidom from types import StringType, UnicodeType import cPickle @@ -43,28 +42,6 @@ ScriptDirectory = os.path.split(os.path.realpath(__file__))[0] -""" -pyxsval is not complete and the parts that are not supported print some error -reports. This class is used for not displaying them -""" -class HolePseudoFile: - """ Base class for file like objects to facilitate StdOut for the Shell.""" - def __init__(self, output = None): - if output is None: output = [] - self.output = output - - def writelines(self, l): - map(self.write, l) - - def write(self, s): - pass - - def flush(self): - pass - - def isatty(self): - return false - #------------------------------------------------------------------------------- # Undo Buffer for PLCOpenEditor #------------------------------------------------------------------------------- @@ -164,7 +141,6 @@ # Reset PLCControler internal variables def Reset(self): - self.VerifyXML = False self.Project = None self.ProjectBuffer = None self.Buffering = False @@ -193,8 +169,8 @@ # Create the project self.Project = plcopen.project() properties["creationDateTime"] = datetime(*localtime()[:6]) - self.Project.setFileHeader(properties) - self.Project.setContentHeader(properties) + self.Project.setfileHeader(properties) + self.Project.setcontentHeader(properties) self.SetFilePath("") # Initialize the project buffer self.ProjectBuffer = UndoBuffer(self.Copy(self.Project), False) @@ -203,31 +179,31 @@ # Return project data type names def GetProjectDataTypeNames(self): if self.Project: - return [datatype.getName() for datatype in self.Project.getDataTypes()] + return [datatype.getname() for datatype in self.Project.getdataTypes()] return [] # Return project pou names def GetProjectPouNames(self): if self.Project: - return [pou.getName() for pou in self.Project.getPous()] + return [pou.getname() for pou in self.Project.getpous()] return [] # Return project pou names def GetProjectConfigNames(self): if self.Project: - return [config.getName() for config in self.Project.getConfigurations()] + return [config.getName() for config in self.Project.getconfigurations()] return [] # Return project pou variables def GetProjectPouVariables(self, pou_name=None): variables = [] - for pou in self.Project.getPous(): - if not pou_name or pou_name == pou.getName(): + for pou in self.Project.getpous(): + if not pou_name or pou_name == pou.getname(): variables.extend([var["Name"] for var in self.GetPouInterfaceVars(pou)]) - for transition in pou.getTransitionList(): - variables.append(transition.getName()) - for action in pou.getActionList(): - variables.append(action.getName()) + for transition in pou.gettransitionList(): + variables.append(transition.getname()) + for action in pou.getactionList(): + variables.append(action.getname()) return variables # Return if project is saved @@ -261,52 +237,52 @@ # Change project properties def SetProjectProperties(self, name = None, properties = None): if name != None: - self.Project.setName(name) + self.Project.setname(name) if properties != None: - self.Project.setFileHeader(properties) - self.Project.setContentHeader(properties) + self.Project.setfileHeader(properties) + self.Project.setcontentHeader(properties) if name != None or properties != None: self.BufferProject() # Return project properties def GetProjectProperties(self): - properties = self.Project.getFileHeader() - properties.update(self.Project.getContentHeader()) + properties = self.Project.getfileHeader() + properties.update(self.Project.getcontentHeader()) return properties # Return project informations def GetProjectInfos(self): if self.Project: - infos = {"name": self.Project.getName(), "type": ITEM_PROJECT} + infos = {"name": self.Project.getname(), "type": ITEM_PROJECT} datatypes = {"name": "Data Types", "type": ITEM_UNEDITABLE, "values":[]} - for datatype in self.Project.getDataTypes(): - datatypes["values"].append({"name": datatype.getName(), "type": ITEM_DATATYPE, "values": []}) + for datatype in self.Project.getdataTypes(): + datatypes["values"].append({"name": datatype.getname(), "type": ITEM_DATATYPE, "values": []}) pou_types = {"function": {"name": "Functions", "type": ITEM_UNEDITABLE, "values":[]}, "functionBlock": {"name": "Function Blocks", "type": ITEM_UNEDITABLE, "values":[]}, "program": {"name": "Programs", "type": ITEM_UNEDITABLE, "values":[]}} - for pou in self.Project.getPous(): - pou_type = pou.getPouType().getValue() - pou_infos = {"name": pou.getName(), "type": ITEM_POU} + for pou in self.Project.getpous(): + pou_type = pou.getpouType() + pou_infos = {"name": pou.getname(), "type": ITEM_POU} pou_values = [] - if pou.getBodyType() == "SFC": + if pou.getbodyType() == "SFC": transitions = [] - for transition in pou.getTransitionList(): - transitions.append({"name": transition.getName(), "type": ITEM_TRANSITION, "values": []}) + for transition in pou.gettransitionList(): + transitions.append({"name": transition.getname(), "type": ITEM_TRANSITION, "values": []}) pou_values.append({"name": "Transitions", "type": ITEM_UNEDITABLE, "values": transitions}) actions = [] - for action in pou.getActionList(): - actions.append({"name": action.getName(), "type": ITEM_ACTION, "values": []}) + for action in pou.getactionList(): + actions.append({"name": action.getname(), "type": ITEM_ACTION, "values": []}) pou_values.append({"name": "Actions", "type": ITEM_UNEDITABLE, "values": actions}) if pou_type in pou_types: pou_infos["values"] = pou_values pou_types[pou_type]["values"].append(pou_infos) configurations = {"name": "Configurations", "type": ITEM_UNEDITABLE, "values": []} - for config in self.Project.getConfigurations(): - config_name = config.getName() + for config in self.Project.getconfigurations(): + config_name = config.getname() config_infos = {"name": config_name, "type": ITEM_CONFIGURATION, "values": []} resources = {"name": "Resources", "type": ITEM_UNEDITABLE, "values": []} - for resource in config.getResource(): - resource_name = resource.getName() + for resource in config.getresource(): + resource_name = resource.getname() resource_infos = {"name": resource_name, "type": ITEM_RESOURCE, "values": []} resources["values"].append(resource_infos) config_infos["values"] = [resources] @@ -322,24 +298,24 @@ # Reset the tree of user-defined pou cross-use self.DataTypeUsingTree = {} if self.Project: - datatypes = self.Project.getDataTypes() + datatypes = self.Project.getdataTypes() # Reference all the user-defined data type names and initialize the tree of # user-defined data type cross-use - datatypenames = [datatype.getName() for datatype in datatypes] + datatypenames = [datatype.getname() for datatype in datatypes] for name in datatypenames: self.DataTypeUsingTree[name] = [] # Analyze each data type for datatype in datatypes: - name = datatype.getName() - basetype_content = datatype.getBaseType().getContent() + name = datatype.getname() + basetype_content = datatype.getbaseType().getcontent() if basetype_content["name"] == "derived": - basetype_name = basetype_content["value"].getName() + basetype_name = basetype_content["value"].getname() if basetype_name in datatypenames and name not in self.DataTypeUsingTree[basetype_name]: self.DataTypeUsingTree[basetype_name].append(name) elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned", "array"]: - base_type = basetype_content["value"].baseType.getContent() + base_type = basetype_content["value"].baseType.getcontent() if base_type["value"] is not None: - basetype_name = base_type["value"].getName() + basetype_name = base_type["value"].getname() if basetype_name in datatypenames and name not in self.DataTypeUsingTree[basetype_name]: self.DataTypeUsingTree[basetype_name].append(name) @@ -348,37 +324,37 @@ # Reset the tree of user-defined pou cross-use self.PouUsingTree = {} if self.Project: - pous = self.Project.getPous() + pous = self.Project.getpous() # Reference all the user-defined pou names and initialize the tree of # user-defined pou cross-use - pounames = [pou.getName() for pou in pous] + pounames = [pou.getname() for pou in pous] for name in pounames: self.PouUsingTree[name] = [] # Analyze each pou for pou in pous: - name = pou.getName() + name = pou.getname() if pou.interface: # Extract variables from every varLists - for type, varlist in pou.getVars(): - for var in varlist.getVariable(): - vartype_content = var.getType().getContent() + for type, varlist in pou.getvars(): + for var in varlist.getvariable(): + vartype_content = var.gettype().getcontent() if vartype_content["name"] == "derived": - typename = vartype_content["value"].getName() + typename = vartype_content["value"].getname() if typename in pounames and name not in self.PouUsingTree[typename]: self.PouUsingTree[typename].append(name) - bodytype = pou.getBodyType() + bodytype = pou.getbodyType() # If pou is written in a graphical language if bodytype in ["FBD","LD","SFC"]: # Analyze each instance of the pou - for instance in pou.getInstances(): - if isinstance(instance, plcopen.block): - typename = instance.getTypeName() + for instance in pou.getinstances(): + if isinstance(instance, plcopen.fbdObjects_block): + typename = instance.gettypeName() # Update tree if there is a cross-use if typename in pounames and name not in self.PouUsingTree[typename]: self.PouUsingTree[typename].append(name) # If pou is written in a textual language elif bodytype in ["IL", "ST"]: - text = pou.getText() + text = pou.gettext() # Search if each pou is mentioned in the pou text for typename in pounames: typename_model = re.compile("[ \t\n]%s[ \t\n]"%typename) @@ -450,14 +426,14 @@ # Add a Data Type to Project def ProjectAddDataType(self, datatype_name): # Add the pou to project - self.Project.appendDataType(datatype_name) + self.Project.appenddataType(datatype_name) self.RefreshDataTypeUsingTree() self.RefreshDataTypes() self.BufferProject() # Remove a Data Type from project def ProjectRemoveDataType(self, datatype_name): - self.Project.removeDataType(datatype_name) + self.Project.removedataType(datatype_name) self.RefreshDataTypeUsingTree() self.RefreshDataTypes() self.BufferProject() @@ -465,7 +441,7 @@ # Add a Pou to Project def ProjectAddPou(self, pou_name, pou_type, body_type): # Add the pou to project - self.Project.appendPou(pou_name, pou_type, body_type) + self.Project.appendpou(pou_name, pou_type, body_type) if pou_type == "function": self.SetPouInterfaceReturnType(pou_name, "BOOL") self.RefreshPouUsingTree() @@ -474,47 +450,47 @@ # Remove a Pou from project def ProjectRemovePou(self, pou_name): - self.Project.removePou(pou_name) + self.Project.removepou(pou_name) self.RefreshPouUsingTree() self.RefreshBlockTypes() self.BufferProject() # Add a configuration to Project def ProjectAddConfiguration(self, config_name): - self.Project.addConfiguration(config_name) + self.Project.addconfiguration(config_name) self.BufferProject() # Remove a configuration from project def ProjectRemoveConfiguration(self, config_name): - self.Project.removeConfiguration(config_name) + self.Project.removeconfiguration(config_name) self.BufferProject() # Add a resource to a configuration of the Project def ProjectAddConfigurationResource(self, config_name, resource_name): - self.Project.addConfigurationResource(config_name, resource_name) + self.Project.addconfigurationResource(config_name, resource_name) self.BufferProject() # Remove a resource from a configuration of the project def ProjectRemoveConfigurationResource(self, config_name, resource_name): - self.Project.removeConfigurationResource(config_name, resource_name) + self.Project.removeconfigurationResource(config_name, resource_name) self.BufferProject() # Add a Transition to a Project Pou def ProjectAddPouTransition(self, pou_name, transition_name, transition_type): - pou = self.Project.getPou(pou_name) - pou.addTransition(transition_name, transition_type) + pou = self.Project.getpou(pou_name) + pou.addtransition(transition_name, transition_type) self.BufferProject() # Remove a Transition from a Project Pou def ProjectRemovePouTransition(self, pou_name, transition_name): - pou = self.Project.getPou(pou_name) - pou.removeTransition(transition_name) + pou = self.Project.getpou(pou_name) + pou.removetransition(transition_name) self.BufferProject() # Add an Action to a Project Pou def ProjectAddPouAction(self, pou_name, action_name, action_type): - pou = self.Project.getPou(pou_name) - pou.addAction(action_name, action_type) + pou = self.Project.getpou(pou_name) + pou.addaction(action_name, action_type) self.BufferProject() # Remove an Action from a Project Pou @@ -524,23 +500,23 @@ words = element.split("::") if words[0] == "A" and words[1] == pou_name and words[2] == action_name: self.RemoveElementEditing(i) - pou = self.Project.getPou(pou_name) - pou.removeAction(action_name) + pou = self.Project.getpou(pou_name) + pou.removeaction(action_name) self.BufferProject() # Change the name of a pou def ChangeDataTypeName(self, old_name, new_name): # Found the pou corresponding to old name and change its name to new name - datatype = self.Project.getDataType(old_name) - datatype.setName(new_name) + datatype = self.Project.getdataType(old_name) + datatype.setname(new_name) self.Project.updateElementName(old_name, new_name) self.BufferProject() # Change the name of a pou def ChangePouName(self, old_name, new_name): # Found the pou corresponding to old name and change its name to new name - pou = self.Project.getPou(old_name) - pou.setName(new_name) + pou = self.Project.getpou(old_name) + pou.setname(new_name) self.Project.updateElementName(old_name, new_name) self.RefreshPouUsingTree() self.RefreshBlockTypes() @@ -549,98 +525,98 @@ # Change the name of a pou transition def ChangePouTransitionName(self, pou_name, old_name, new_name): # Found the pou transition corresponding to old name and change its name to new name - pou = self.Project.getPou(pou_name) - transition = pou.getTransition(old_name) - transition.setName(new_name) + pou = self.Project.getpou(pou_name) + transition = pou.gettransition(old_name) + transition.setname(new_name) pou.updateElementName(old_name, new_name) self.BufferProject() # Change the name of a pou action def ChangePouActionName(self, pou_name, old_name, new_name): # Found the pou action corresponding to old name and change its name to new name - pou = self.Project.getPou(pou_name) - action = pou.getAction(old_name) - action.setName(new_name) + pou = self.Project.getpou(pou_name) + action = pou.getaction(old_name) + action.setname(new_name) pou.updateElementName(old_name, new_name) self.BufferProject() # Change the name of a pou variable def ChangePouVariableName(self, pou_name, old_name, new_name): # Found the pou action corresponding to old name and change its name to new name - pou = self.Project.getPou(pou_name) - for type, varlist in pou.getVars(): - for var in varlist.getVariable(): - if var.getName() == old_name: - var.setName(new_name) + pou = self.Project.getpou(pou_name) + for type, varlist in pou.getvars(): + for var in varlist.getvariable(): + if var.getname() == old_name: + var.setname(new_name) self.RefreshBlockTypes() self.BufferProject() # Change the name of a configuration def ChangeConfigurationName(self, old_name, new_name): # Found the configuration corresponding to old name and change its name to new name - configuration = self.Project.getConfiguration(old_name) - configuration.setName(new_name) + configuration = self.Project.getconfiguration(old_name) + configuration.setname(new_name) self.BufferProject() # Change the name of a configuration resource def ChangeConfigurationResourceName(self, config_name, old_name, new_name): # Found the resource corresponding to old name and change its name to new name - resource = self.Project.getConfigurationResource(config_name) + resource = self.Project.getconfigurationResource(config_name) resource.setName(new_name) self.BufferProject() # Return the type of the pou given by its name def GetPouType(self, name): # Found the pou correponding to name and return its type - pou = self.Project.getPou(name) - return pou.pouType.getValue() + pou = self.Project.getpou(name) + return pou.getpouType() # Return pous with SFC language def GetSFCPous(self): list = [] if self.Project: - for pou in self.Project.getPous(): + for pou in self.Project.getpous(): if pou.getBodyType() == "SFC": - list.append(pou.getName()) + list.append(pou.getname()) return list # Return the body language of the pou given by its name def GetPouBodyType(self, name): # Found the pou correponding to name and return its body language - pou = self.Project.getPou(name) - return pou.getBodyType() + pou = self.Project.getpou(name) + return pou.getbodyType() # Return the actions of a pou def GetPouTransitions(self, pou_name): transitions = [] - pou = self.Project.getPou(pou_name) - if pou.getBodyType() == "SFC": - for transition in pou.getTransitionList(): - transitions.append(transition.getName()) + pou = self.Project.getpou(pou_name) + if pou.getbodyType() == "SFC": + for transition in pou.gettransitionList(): + transitions.append(transition.getname()) return transitions # Return the body language of the transition given by its name def GetTransitionBodyType(self, pou_name, pou_transition): # Found the pou correponding to name and return its body language - pou = self.Project.getPou(pou_name) - transition = pou.getTransition(pou_transition) - return transition.getBodyType() + pou = self.Project.getpou(pou_name) + transition = pou.gettransition(pou_transition) + return transition.getbodyType() # Return the actions of a pou def GetPouActions(self, pou_name): actions = [] - pou = self.Project.getPou(pou_name) - if pou.getBodyType() == "SFC": - for action in pou.getActionList(): - actions.append(action.getName()) + pou = self.Project.getpou(pou_name) + if pou.getbodyType() == "SFC": + for action in pou.getactionList(): + actions.append(action.getname()) return actions # Return the body language of the pou given by its name def GetActionBodyType(self, pou_name, pou_action): # Found the pou correponding to name and return its body language - pou = self.Project.getPou(pou_name) - action = pou.getAction(pou_action) - return action.getBodyType() + pou = self.Project.getpou(pou_name) + action = pou.getaction(pou_action) + return action.getbodyType() # Extract varlists from a list of vars def ExtractVarLists(self, vars): @@ -650,47 +626,62 @@ for var in vars: if current_type != (var["Class"], var["Retain"], var["Constant"], var["Location"] in ["", None]): current_type = (var["Class"], var["Retain"], var["Constant"], var["Location"] in ["", None]) - current_varlist = plcopen.varList() + if var["Class"] == "Local": + current_varlist = plcopen.interface_localVars() + elif var["Class"] == "Global": + current_varlist = plcopen.interface_globalVars() + elif var["Class"] == "External": + current_varlist = plcopen.interface_externalVars() + elif var["Class"] == "Temp": + current_varlist = plcopen.interface_tempVars() + elif var["Class"] == "Input": + current_varlist = plcopen.interface_inputVars() + elif var["Class"] == "Output": + current_varlist = plcopen.interface_outputVars() + elif var["Class"] == "InOut": + current_varlist = plcopen.interface_inOutVars() + else: + current_varlist = plcopen.varList() varlist_list.append((var["Class"], current_varlist)) if var["Retain"] == "Yes": - varlist.setRetain(True) + current_varlist.setretain(True) if var["Constant"] == "Yes": - varlist.setConstant(True) + current_varlist.setconstant(True) # Create variable and change its properties tempvar = plcopen.varListPlain_variable() - tempvar.setName(var["Name"]) + tempvar.setname(var["Name"]) var_type = plcopen.dataType() - if var["Type"] not in var_type.getChoices(): + if var["Type"] in self.GetBaseTypes(): if var["Type"] == "STRING": - var_type.setContent("string", plcopen.string()) + var_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()}) elif var["Type"] == "WSTRING": - var_type.setContent("wstring", plcopen.wstring()) + var_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()}) else: - derived_type = plcopen.derived() - derived_type.setName(var["Type"]) - var_type.setContent("derived", derived_type) + var_type.setcontent({"name" : var["Type"], "value" : None}) else: - var_type.setContent(var["Type"], None) - tempvar.setType(var_type) + derived_type = plcopen.derivedTypes_derived() + derived_type.setname(var["Type"]) + var_type.setcontent({"name" : "derived", "value" : derived_type}) + tempvar.settype(var_type) if var["Initial Value"] != "": value = plcopen.value() - value.setValue(var["Initial Value"]) - tempvar.setInitialValue(value) + value.setvalue(var["Initial Value"]) + tempvar.setinitialValue(value) if var["Location"] != "": - tempvar.setAddress(var["Location"]) + tempvar.setaddress(var["Location"]) else: - tempvar.setAddress(None) + tempvar.setaddress(None) # Add variable to varList - current_varlist.appendVariable(tempvar) + current_varlist.appendvariable(tempvar) return varlist_list # Replace the configuration globalvars by those given def SetConfigurationGlobalVars(self, name, vars): # Found the configuration corresponding to name - configuration = self.Project.getConfiguration(name) + configuration = self.Project.getconfiguration(name) if configuration: # Set configuration global vars - configuration.setGlobalVars([]) + configuration.setglobalVars([]) for vartype, varlist in self.ExtractVarLists(vars): configuration.globalVars.append(varlist) self.RefreshBlockTypes() @@ -699,35 +690,35 @@ def GetConfigurationGlobalVars(self, name): vars = [] # Found the configuration corresponding to name - configuration = self.Project.getConfiguration(name) + configuration = self.Project.getconfiguration(name) if configuration: # Extract variables from every varLists - for varlist in configuration.getGlobalVars(): - for var in varlist.getVariable(): - tempvar = {"Name":var.getName(),"Class":"Global"} - vartype_content = var.getType().getContent() + for varlist in configuration.getglobalVars(): + for var in varlist.getvariable(): + tempvar = {"Name" : var.getname(), "Class" : "Global"} + vartype_content = var.gettype().getcontent() if vartype_content["name"] == "derived": - tempvar["Type"] = vartype_content["value"].getName() + tempvar["Type"] = vartype_content["value"].getname() elif vartype_content["name"] in ["string", "wstring"]: tempvar["Type"] = vartype_content["name"].upper() else: tempvar["Type"] = vartype_content["name"] tempvar["Edit"] = True - initial = var.getInitialValue() + initial = var.getinitialValue() if initial: - tempvar["Initial Value"] = initial.getValue() + tempvar["Initial Value"] = initial.getvalue() else: tempvar["Initial Value"] = "" - address = var.getAddress() + address = var.getaddress() if address: tempvar["Location"] = address else: tempvar["Location"] = "" - if varlist.getRetain(): + if varlist.getretain(): tempvar["Retain"] = "Yes" else: tempvar["Retain"] = "No" - if varlist.getConstant(): + if varlist.getconstant(): tempvar["Constant"] = "Yes" else: tempvar["Constant"] = "No" @@ -737,10 +728,10 @@ # Replace the resource globalvars by those given def SetConfigurationResourceGlobalVars(self, config_name, name, vars): # Found the resource corresponding to name - resource = self.Project.getConfigurationResource(config_name, name) + resource = self.Project.getconfigurationResource(config_name, name) # Set resource global vars if resource: - resource.setGlobalVars([]) + resource.setglobalVars([]) for vartype, varlist in self.ExtractVarLists(vars): resource.globalVars.append(varlist) self.RefreshBlockTypes() @@ -749,35 +740,35 @@ def GetConfigurationResourceGlobalVars(self, config_name, name): vars = [] # Found the resource corresponding to name - resource = self.Project.getConfigurationResource(config_name, name) + resource = self.Project.getconfigurationResource(config_name, name) if resource: # Extract variables from every varLists - for varlist in resource.getGlobalVars(): - for var in varlist.getVariable(): - tempvar = {"Name":var.getName(),"Class":"Global"} - vartype_content = var.getType().getContent() + for varlist in resource.getglobalVars(): + for var in varlist.getvariable(): + tempvar = {"Name" : var.getname(), "Class" : "Global"} + vartype_content = var.gettype().getcontent() if vartype_content["name"] == "derived": - tempvar["Type"] = vartype_content["value"].getName() + tempvar["Type"] = vartype_content["value"].getname() elif vartype_content["name"] in ["string", "wstring"]: tempvar["Type"] = vartype_content["name"].upper() else: tempvar["Type"] = vartype_content["name"] tempvar["Edit"] = True - initial = var.getInitialValue() + initial = var.getinitialValue() if initial: - tempvar["Initial Value"] = initial.getValue() + tempvar["Initial Value"] = initial.getvalue() else: tempvar["Initial Value"] = "" - address = var.getAddress() + address = var.getaddress() if address: tempvar["Location"] = address else: tempvar["Location"] = "" - if varlist.getRetain(): + if varlist.getretain(): tempvar["Retain"] = "Yes" else: tempvar["Retain"] = "No" - if varlist.getConstant(): + if varlist.getconstant(): tempvar["Constant"] = "Yes" else: tempvar["Constant"] = "No" @@ -787,7 +778,7 @@ # Return the interface of the pou given by its name def GetPouInterfaceVarsByName(self, name): # Found the pou correponding to name and return the interface - return self.GetPouInterfaceVars(self.Project.getPou(name)) + return self.GetPouInterfaceVars(self.Project.getpou(name)) # Return the interface for the given pou def GetPouInterfaceVars(self, pou): @@ -795,34 +786,34 @@ # Verify that the pou has an interface if pou.interface: # Extract variables from every varLists - for type, varlist in pou.getVars(): - for var in varlist.getVariable(): - tempvar = {"Name":var.getName(),"Class":type} - vartype_content = var.getType().getContent() + for type, varlist in pou.getvars(): + for var in varlist.getvariable(): + tempvar = {"Name" : var.getname(), "Class" : type} + vartype_content = var.gettype().getcontent() if vartype_content["name"] == "derived": - tempvar["Type"] = vartype_content["value"].getName() - tempvar["Edit"] = not pou.hasBlock(tempvar["Name"]) + tempvar["Type"] = vartype_content["value"].getname() + tempvar["Edit"] = not pou.hasblock(tempvar["Name"]) else: if vartype_content["name"] in ["string", "wstring"]: tempvar["Type"] = vartype_content["name"].upper() else: tempvar["Type"] = vartype_content["name"] tempvar["Edit"] = True - initial = var.getInitialValue() + initial = var.getinitialValue() if initial: - tempvar["Initial Value"] = initial.getValue() + tempvar["Initial Value"] = initial.getvalue() else: tempvar["Initial Value"] = "" - address = var.getAddress() + address = var.getaddress() if address: tempvar["Location"] = address else: tempvar["Location"] = "" - if varlist.getRetain(): + if varlist.getretain(): tempvar["Retain"] = "Yes" else: tempvar["Retain"] = "No" - if varlist.getConstant(): + if varlist.getconstant(): tempvar["Constant"] = "Yes" else: tempvar["Constant"] = "No" @@ -832,31 +823,36 @@ # Replace the Pou interface by the one given def SetPouInterfaceVars(self, name, vars): # Found the pou corresponding to name and add interface if there isn't one yet - pou = self.Project.getPou(name) + pou = self.Project.getpou(name) if not pou.interface: pou.interface = plcopen.pou_interface() # Set Pou interface - pou.setVars(self.ExtractVarLists(vars)) + pou.setvars(self.ExtractVarLists(vars)) self.RefreshPouUsingTree() self.RefreshBlockTypes() # Replace the return type of the pou given by its name (only for functions) def SetPouInterfaceReturnType(self, name, type): - pou = self.Project.getPou(name) + pou = self.Project.getpou(name) if not pou.interface: pou.interface = plcopen.pou_interface() # If there isn't any return type yet, add it - return_type = pou.interface.getReturnType() + return_type = pou.interface.getreturnType() if not return_type: return_type = plcopen.dataType() - pou.interface.setReturnType(return_type) + pou.interface.setreturnType(return_type) # Change return type if type in self.GetBaseTypes(): - return_type.setContent(type, None) + if type == "STRING": + return_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()}) + elif type == "WSTRING": + return_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()}) + else: + return_type.setcontent({"name" : type, "value" : None}) else: - derived_type = plcopen.derived() - derived_type.setName(type) - return_type.setContent("derived", derived_type) + derived_type = plcopen.derivedTypes_derived() + derived_type.setname(type) + return_type.setcontent({"name" : "derived", "value" : derived_type}) self.RefreshBlockTypes() def UpdateProjectUsedPous(self, old_name, new_name): @@ -871,18 +867,18 @@ # Return the return type of the pou given by its name def GetPouInterfaceReturnTypeByName(self, name): # Found the pou correponding to name and return the return type - return self.GetPouInterfaceReturnType(self.Project.getPou(name)) + return self.GetPouInterfaceReturnType(self.Project.getpou(name)) # Return the return type of the given pou def GetPouInterfaceReturnType(self, pou): # Verify that the pou has an interface if pou.interface: # Return the return type if there is one - return_type = pou.interface.getReturnType() + return_type = pou.interface.getreturnType() if return_type: - returntype_content = return_type.getContent() + returntype_content = return_type.getcontent() if returntype_content["name"] == "derived": - return returntype_content["value"].getName() + return returntype_content["value"].getname() elif returntype_content["name"] in ["string", "wstring"]: return returntype_content["name"].upper() else: @@ -894,26 +890,26 @@ ResetTypeHierarchy() ResetEnumeratedDataValues() if self.Project: - for datatype in self.Project.getDataTypes(): - name = datatype.getName() - basetype_content = datatype.getBaseType().getContent() + for datatype in self.Project.getdataTypes(): + name = datatype.getname() + basetype_content = datatype.getbaseType().getcontent() if basetype_content["value"] is None: AddDataTypeHierarchy(name, basetype_content["name"]) elif basetype_content["name"] in ["string", "wstring"]: AddDataTypeHierarchy(name, basetype_content["name"].upper()) elif basetype_content["name"] == "derived": - AddDataTypeHierarchy(name, basetype_content["value"].getName()) + AddDataTypeHierarchy(name, basetype_content["value"].getname()) elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]: - base_type = basetype_content["value"].baseType.getContent() + base_type = basetype_content["value"].baseType.getcontent() if base_type["value"] is None: AddDataTypeHierarchy(name, base_type["name"]) else: - AddDataTypeHierarchy(name, base_type["value"].getName()) + AddDataTypeHierarchy(name, base_type["value"].getname()) else: if basetype_content["name"] == "enum": values = [] - for value in basetype_content["value"].values.getValue(): - values.append(value.getName()) + for value in basetype_content["value"].values.getvalue(): + values.append(value.getname()) AddEnumeratedDataValues(values) AddDataTypeHierarchy(name, "ANY_DERIVED") @@ -924,58 +920,58 @@ else: BlockTypes.append({"name" : "User-defined POUs", "list": []}) if self.Project: - for pou in self.Project.getPous(): - pou_name = pou.getName() - pou_type = pou.pouType.getValue() + for pou in self.Project.getpous(): + pou_name = pou.getname() + pou_type = pou.getpouType() if pou_type != "program": block_infos = {"name" : pou_name, "type" : pou_type, "extensible" : False, "inputs" : [], "outputs" : [], "comment" : "", "generate" : generate_block, "initialise" : initialise_block } - if pou.getInterface(): - for type, varlist in pou.getVars(): + if pou.getinterface(): + for type, varlist in pou.getvars(): if type == "InOut": - for var in varlist.getVariable(): - var_type = var.type.getContent() + for var in varlist.getvariable(): + var_type = var.type.getcontent() if var_type["name"] == "derived": - block_infos["inputs"].append((var.getName(),var_type["value"].getName(),"none")) - block_infos["outputs"].append((var.getName(),var_type["value"].getName(),"none")) + block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none")) + block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none")) elif var_type["name"] in ["string", "wstring"]: - block_infos["inputs"].append((var.getName(),var_type["name"].upper(),"none")) - block_infos["outputs"].append((var.getName(),var_type["name"].upper(),"none")) + block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none")) + block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none")) else: - block_infos["inputs"].append((var.getName(),var_type["name"],"none")) - block_infos["outputs"].append((var.getName(),var_type["name"],"none")) + block_infos["inputs"].append((var.getname(), var_type["name"], "none")) + block_infos["outputs"].append((var.getname(), var_type["name"], "none")) elif type == "Input": - for var in varlist.getVariable(): - var_type = var.type.getContent() + for var in varlist.getvariable(): + var_type = var.type.getcontent() if var_type["name"] == "derived": - block_infos["inputs"].append((var.getName(),var_type["value"].getName(),"none")) + block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none")) elif var_type["name"] in ["string", "wstring"]: - block_infos["inputs"].append((var.getName(),var_type["name"].upper(),"none")) + block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none")) else: - block_infos["inputs"].append((var.getName(),var_type["name"],"none")) + block_infos["inputs"].append((var.getname(), var_type["name"], "none")) elif type == "Output": - for var in varlist.getVariable(): - var_type = var.type.getContent() + for var in varlist.getvariable(): + var_type = var.type.getcontent() if var_type["name"] == "derived": - block_infos["outputs"].append((var.getName(),var_type["value"].getName(),"none")) + block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none")) elif var_type["name"] in ["string", "wstring"]: - block_infos["outputs"].append((var.getName(),var_type["name"].upper(),"none")) + block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none")) else: - block_infos["outputs"].append((var.getName(),var_type["name"],"none")) - return_type = pou.interface.getReturnType() + block_infos["outputs"].append((var.getname(), var_type["name"], "none")) + return_type = pou.interface.getreturnType() if return_type: - var_type = return_type.getContent() + var_type = return_type.getcontent() if var_type["name"] == "derived": - block_infos["outputs"].append(("",var_type["value"].getName(),"none")) + block_infos["outputs"].append(("", var_type["value"].getname(), "none")) elif var_type["name"] in ["string", "wstring"]: - block_infos["outputs"].append(("",var_type["name"].upper(),"none")) + block_infos["outputs"].append(("", var_type["name"].upper(), "none")) else: - block_infos["outputs"].append(("",var_type["name"],"none")) - if pou.getBodyType() in ["FBD","LD","SFC"]: - for instance in pou.getInstances(): - if isinstance(instance, plcopen.comment): - block_infos["comment"] = instance.getContentText() + block_infos["outputs"].append(("", var_type["name"], "none")) + if pou.getbodyType() in ["FBD","LD","SFC"]: + for instance in pou.getinstances(): + if isinstance(instance, plcopen.commonObjects_comment): + block_infos["comment"] = instance.getcontentText() BlockTypes[-1]["list"].append(block_infos) # Return Block types checking for recursion @@ -1033,9 +1029,9 @@ if blocktype["type"] == "program": blocktypes.append(blocktype["name"]) if self.Project: - for pou in self.Project.getPous(): - if pou.pouType.getValue() == "program": - blocktypes.append(pou.getName()) + for pou in self.Project.getpous(): + if pou.getpouType() == "program": + blocktypes.append(pou.getname()) return blocktypes # Return Data Types checking for recursion @@ -1050,8 +1046,8 @@ name = words[1] else: name = "" - for datatype in self.Project.getDataTypes(): - datatype_name = datatype.getName() + for datatype in self.Project.getdataTypes(): + datatype_name = datatype.getname() if datatype_name != name and not self.DataTypeIsUsedBy(name, datatype_name): datatypes.append(datatype_name) return datatypes @@ -1105,40 +1101,40 @@ words = tagname.split("::") if words[0] == "D": infos = {} - datatype = self.Project.getDataType(words[1]) - basetype_content = datatype.baseType.getContent() + datatype = self.Project.getdataType(words[1]) + basetype_content = datatype.baseType.getcontent() if basetype_content["value"] is None: infos["type"] = "Directly" infos["base_type"] = basetype_content["name"] elif basetype_content["name"] == "derived": infos["type"] = "Directly" - infos["base_type"] = basetype_content["value"].getName() + infos["base_type"] = basetype_content["value"].getname() elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]: infos["type"] = "Subrange" - infos["min"] = basetype_content["value"].range.getLower() - infos["max"] = basetype_content["value"].range.getUpper() - base_type = basetype_content["value"].baseType.getContent() + infos["min"] = basetype_content["value"].range.getlower() + infos["max"] = basetype_content["value"].range.getupper() + base_type = basetype_content["value"].baseType.getcontent() if base_type["value"] is None: infos["base_type"] = base_type["name"] else: - infos["base_type"] = base_type["value"].getName() + infos["base_type"] = base_type["value"].getname() elif basetype_content["name"] == "enum": infos["type"] = "Enumerated" infos["values"] = [] - for value in basetype_content["value"].values.getValue(): - infos["values"].append(value.getName()) + for value in basetype_content["value"].values.getvalue(): + infos["values"].append(value.getname()) elif basetype_content["name"] == "array": infos["type"] = "Array" infos["dimensions"] = [] - for dimension in basetype_content["value"].getDimension(): - infos["dimensions"].append(str(dimension.getUpper())) - base_type = basetype_content["value"].baseType.getContent() + for dimension in basetype_content["value"].getdimension(): + infos["dimensions"].append(str(dimension.getupper())) + base_type = basetype_content["value"].baseType.getcontent() if base_type["value"] is None: infos["base_type"] = base_type["name"] else: - infos["base_type"] = base_type["value"].getName() + infos["base_type"] = base_type["value"].getname() if datatype.initialValue is not None: - infos["initial"] = str(datatype.initialValue.getValue()) + infos["initial"] = str(datatype.initialValue.getvalue()) else: infos["initial"] = "" return infos @@ -1148,64 +1144,67 @@ def SetDataTypeInfos(self, tagname, infos): words = tagname.split("::") if words[0] == "D": - datatype = self.Project.getDataType(words[1]) + datatype = self.Project.getdataType(words[1]) if infos["type"] == "Directly": if infos["base_type"] in self.GetBaseTypes(): if infos["base_type"] == "STRING": - datatype.baseType.setContent("string", plcopen.string()) + datatype.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()}) elif infos["base_type"] == "WSTRING": - datatype.baseType.setContent("wstring", plcopen.wstring()) - else: - datatype.baseType.setContent(infos["base_type"], None) + datatype.baseType.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()}) + else: + datatype.baseType.setcontent({"name" : infos["base_type"], "value" : None}) else: - derived_datatype = plcopen.derived() - derived_datatype.setName(infos["base_type"]) - datatype.baseType.setContent("derived", derived_datatype) + derived_datatype = plcopen.derivedTypes_derived() + derived_datatype.setname(infos["base_type"]) + datatype.baseType.setcontent({"name" : "derived", "value" : derived_datatype}) elif infos["type"] == "Subrange": if infos["base_type"] in GetSubTypes("ANY_UINT"): - subrange = plcopen.subrangeUnsigned() - datatype.baseType.setContent("subrangeUnsigned", subrange) + subrange = plcopen.derivedTypes_subrangeUnsigned() + datatype.baseType.setcontent({"name" : "subrangeUnsigned", "value" : subrange}) else: - subrange = plcopen.subrangeSigned() - datatype.baseType.setContent("subrangeSigned", subrange) - subrange.range.setLower(infos["min"]) - subrange.range.setUpper(infos["max"]) + subrange = plcopen.derivedTypes_subrangeSigned() + datatype.baseType.setcontent({"name" : "subrangeSigned", "value" : subrange}) + subrange.range.setlower(infos["min"]) + subrange.range.setupper(infos["max"]) if infos["base_type"] in self.GetBaseTypes(): - subrange.baseType.setContent(infos["base_type"], None) + subrange.baseType.setcontent({"name" : infos["base_type"], "value" : None}) else: - derived_datatype = plcopen.derived() - derived_datatype.setName(infos["base_type"]) - subrange.baseType.setContent("derived", derived_datatype) + derived_datatype = plcopen.derivedTypes_derived() + derived_datatype.setname(infos["base_type"]) + subrange.baseType.setcontent({"name" : "derived", "value" : derived_datatype}) elif infos["type"] == "Enumerated": - enumerated = plcopen.enum() - for enum_value in infos["values"]: + enumerated = plcopen.derivedTypes_enum() + for i, enum_value in enumerate(infos["values"]): value = plcopen.values_value() - value.setName(enum_value) - enumerated.values.appendValue(value) - datatype.baseType.setContent("enum", enumerated) + value.setname(enum_value) + if i == 0: + enumerated.values.setvalue([value]) + else: + enumerated.values.appendvalue(value) + datatype.baseType.setcontent({"name" : "enum", "value" : enumerated}) elif infos["type"] == "Array": - array = plcopen.array() + array = plcopen.derivedTypes_array() for dimension in infos["dimensions"]: dimension_range = plcopen.rangeSigned() - dimension_range.setLower(1) - dimension_range.setUpper(int(dimension)) - array.appendDimension(dimension_range) + dimension_range.setlower(1) + dimension_range.setupper(int(dimension)) + array.appenddimension(dimension_range) if infos["base_type"] in self.GetBaseTypes(): if infos["base_type"] == "STRING": - array.baseType.setContent("string", plcopen.string()) + array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()}) elif infos["base_type"] == "WSTRING": - array.baseType.setContent("wstring", plcopen.wstring()) - else: - array.baseType.setContent(infos["base_type"], None) + array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()}) + else: + array.baseType.setcontent({"name" : infos["base_type"], "value" : None}) else: - derived_datatype = plcopen.derived() - derived_datatype.setName(infos["base_type"]) - array.baseType.setContent("derived", derived_datatype) - datatype.baseType.setContent("array", array) + derived_datatype = plcopen.derivedTypes_derived() + derived_datatype.setname(infos["base_type"]) + array.baseType.setcontent({"name" : "derived", "value" : derived_datatype}) + datatype.baseType.setcontent({"name" : "array", "value" : array}) if infos["initial"] != "": if datatype.initialValue is None: datatype.initialValue = plcopen.value() - datatype.initialValue.setValue(infos["initial"]) + datatype.initialValue.setvalue(infos["initial"]) else: datatype.initialValue = None self.RefreshDataTypeUsingTree() @@ -1220,17 +1219,17 @@ def GetEditedElement(self, tagname): words = tagname.split("::") if words[0] == "P": - return self.Project.getPou(words[1]) + return self.Project.getpou(words[1]) if words[0] in ['T', 'A']: - pou = self.Project.getPou(words[1]) + pou = self.Project.getpou(words[1]) if words[0] == 'T': - return pou.getTransition(words[2]) + return pou.gettransition(words[2]) elif words[0] == 'A': - return pou.getAction(words[2]) + return pou.getaction(words[2]) elif words[0] == 'C': - return self.Project.getConfiguration(words[1]) + return self.Project.getconfiguration(words[1]) elif words[0] == 'R': - return self.Project.getConfigurationResource(words[1], words[2]) + return self.Project.getconfigurationResource(words[1], words[2]) return None # Return edited element name @@ -1264,7 +1263,7 @@ def GetEditedElementInterfaceVars(self, tagname): words = tagname.split("::") if words[0] in ["P","T","A"]: - pou = self.Project.getPou(words[1]) + pou = self.Project.getpou(words[1]) return self.GetPouInterfaceVars(pou) return [] @@ -1272,7 +1271,7 @@ def GetEditedElementInterfaceReturnType(self, tagname): words = tagname.split("::") if words[0] == "P": - pou = self.Project.getPou(words[1]) + pou = self.Project.getpou(words[1]) return self.GetPouInterfaceReturnType(pou) elif words[0] == 'T': return "BOOL" @@ -1282,33 +1281,33 @@ def SetEditedElementText(self, tagname, text): element = self.GetEditedElement(tagname) if element != None: - element.setText(text) + element.settext(text) self.RefreshPouUsingTree() # Return the edited element text def GetEditedElementText(self, tagname): element = self.GetEditedElement(tagname) if element != None: - return element.getText() + return element.gettext() return "" # Return the edited element transitions def GetEditedElementTransitions(self, tagname): pou = self.GetEditedElement(tagname) - if pou != None and pou.getBodyType() == "SFC": + if pou != None and pou.getbodyType() == "SFC": transitions = [] - for transition in pou.getTransitionList(): - transitions.append(transition.getName()) + for transition in pou.gettransitionList(): + transitions.append(transition.getname()) return transitions return [] # Return edited element transitions def GetEditedElementActions(self, tagname): pou = self.GetEditedElement(tagname) - if pou != None and pou.getBodyType() == "SFC": + if pou != None and pou.getbodyType() == "SFC": actions = [] - for action in pou.getActionList(): - actions.append(action.getName()) + for action in pou.getactionList(): + actions.append(action.getname()) return actions return [] @@ -1327,284 +1326,284 @@ if element is not None: # if id is defined if id is not None: - instance = element.getInstance(id) + instance = element.getinstance(id) else: - instance = element.getRandomInstance(exclude) + instance = element.getrandomInstance(exclude) if instance is not None: if id is not None: infos["id"] = id else: - infos["id"] = instance.getLocalId() - infos["x"] = instance.getX() - infos["y"] = instance.getY() - infos["height"] = instance.getHeight() - infos["width"] = instance.getWidth() - if isinstance(instance, plcopen.block): - infos["name"] = instance.getInstanceName() - infos["type"] = instance.getTypeName() - executionOrder = instance.getExecutionOrderId() + infos["id"] = instance.getlocalId() + infos["x"] = instance.getx() + infos["y"] = instance.gety() + infos["height"] = instance.getheight() + infos["width"] = instance.getwidth() + if isinstance(instance, plcopen.fbdObjects_block): + infos["name"] = instance.getinstanceName() + infos["type"] = instance.gettypeName() + executionOrder = instance.getexecutionOrderId() if executionOrder is not None: infos["executionOrder"] = executionOrder else: infos["executionOrder"] = 0 infos["connectors"] = {"inputs":[],"outputs":[]} - for variable in instance.inputVariables.getVariable(): + for variable in instance.inputVariables.getvariable(): connector = {} - connector["name"] = variable.getFormalParameter() - connector["position"] = variable.connectionPointIn.getRelPosition() - connector["negated"] = variable.getNegated() - connector["edge"] = variable.getConnectorEdge() + connector["name"] = variable.getformalParameter() + connector["position"] = variable.connectionPointIn.getrelPositionXY() + connector["negated"] = variable.getnegated() + connector["edge"] = variable.getedge() connector["links"] = [] - connections = variable.connectionPointIn.getConnections() + connections = variable.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} connector["links"].append(dic) infos["connectors"]["inputs"].append(connector) - for variable in instance.outputVariables.getVariable(): + for variable in instance.outputVariables.getvariable(): connector = {} - connector["name"] = variable.getFormalParameter() - connector["position"] = variable.connectionPointOut.getRelPosition() - connector["negated"] = variable.getNegated() - connector["edge"] = variable.getConnectorEdge() + connector["name"] = variable.getformalParameter() + connector["position"] = variable.connectionPointOut.getrelPositionXY() + connector["negated"] = variable.getnegated() + connector["edge"] = variable.getedge() infos["connectors"]["outputs"].append(connector) - elif isinstance(instance, plcopen.inVariable): - infos["name"] = instance.getExpression() + elif isinstance(instance, plcopen.fbdObjects_inVariable): + infos["name"] = instance.getexpression() infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"]) infos["type"] = "input" - executionOrder = instance.getExecutionOrderId() + executionOrder = instance.getexecutionOrderId() if executionOrder is not None: infos["executionOrder"] = executionOrder else: infos["executionOrder"] = 0 infos["connector"] = {} - infos["connector"]["position"] = instance.connectionPointOut.getRelPosition() - infos["connector"]["negated"] = instance.getNegated() - infos["connector"]["edge"] = instance.getConnectorEdge() - elif isinstance(instance, plcopen.outVariable): - infos["name"] = instance.getExpression() + infos["connector"]["position"] = instance.connectionPointOut.getrelPositionXY() + infos["connector"]["negated"] = instance.getnegated() + infos["connector"]["edge"] = instance.getedge() + elif isinstance(instance, plcopen.fbdObjects_outVariable): + infos["name"] = instance.getexpression() infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"]) infos["type"] = "output" - executionOrder = instance.getExecutionOrderId() + executionOrder = instance.getexecutionOrderId() if executionOrder is not None: infos["executionOrder"] = executionOrder else: infos["executionOrder"] = 0 infos["connector"] = {} - infos["connector"]["position"] = instance.connectionPointIn.getRelPosition() - infos["connector"]["negated"] = instance.getNegated() - infos["connector"]["edge"] = instance.getConnectorEdge() + infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY() + infos["connector"]["negated"] = instance.getnegated() + infos["connector"]["edge"] = instance.getedge() infos["connector"]["links"] = [] - connections = instance.connectionPointIn.getConnections() + connections = instance.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} infos["connector"]["links"].append(dic) - elif isinstance(instance, plcopen.inOutVariable): - infos["name"] = instance.getExpression() + elif isinstance(instance, plcopen.fbdObjects_inOutVariable): + infos["name"] = instance.getexpression() infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"]) infos["type"] = "inout" - executionOrder = instance.getExecutionOrderId() + executionOrder = instance.getexecutionOrderId() if executionOrder is not None: infos["executionOrder"] = executionOrder else: infos["executionOrder"] = 0 infos["connectors"] = {"input":{},"output":{}} - infos["connectors"]["output"]["position"] = instance.connectionPointOut.getRelPosition() - infos["connectors"]["output"]["negated"] = instance.getNegatedOut() - infos["connectors"]["output"]["edge"] = instance.getOutputEdge() - infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition() - infos["connectors"]["input"]["negated"] = instance.getNegatedIn() - infos["connectors"]["input"]["edge"] = instance.getInputEdge() + infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY() + infos["connectors"]["output"]["negated"] = instance.getnegatedOut() + infos["connectors"]["output"]["edge"] = instance.getedgeOut() + infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY() + infos["connectors"]["input"]["negated"] = instance.getnegatedIn() + infos["connectors"]["input"]["edge"] = instance.getedgeIn() infos["connectors"]["input"]["links"] = [] - connections = instance.connectionPointIn.getConnections() + connections = instance.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} infos["connectors"]["input"]["links"].append(dic) - elif isinstance(instance, plcopen.continuation): - infos["name"] = instance.getName() + elif isinstance(instance, plcopen.commonObjects_continuation): + infos["name"] = instance.getname() infos["type"] = "continuation" infos["connector"] = {} - infos["connector"]["position"] = instance.connectionPointOut.getRelPosition() - elif isinstance(instance, plcopen.connector): + infos["connector"]["position"] = instance.connectionPointOut.getrelPositionXY() + elif isinstance(instance, plcopen.commonObjects_connector): infos["name"] = instance.getName() infos["type"] = "connection" infos["connector"] = {} - infos["connector"]["position"] = instance.connectionPointIn.getRelPosition() + infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY() infos["connector"]["links"] = [] - connections = instance.connectionPointIn.getConnections() + connections = instance.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} infos["connector"]["links"].append(dic) - elif isinstance(instance, plcopen.comment): + elif isinstance(instance, plcopen.commonObjects_comment): infos["type"] = "comment" - infos["content"] = instance.getContentText() - elif isinstance(instance, plcopen.leftPowerRail): + infos["content"] = instance.getcontentText() + elif isinstance(instance, plcopen.ldObjects_leftPowerRail): infos["type"] = "leftPowerRail" infos["connectors"] = [] - for connection in instance.getConnectionPointOut(): + for connection in instance.getconnectionPointOut(): connector = {} - connector["position"] = connection.getRelPosition() + connector["position"] = connection.getrelPositionXY() infos["connectors"].append(connector) - elif isinstance(instance, plcopen.rightPowerRail): + elif isinstance(instance, plcopen.ldObjects_rightPowerRail): infos["type"] = "rightPowerRail" infos["connectors"] = [] - for connection in instance.getConnectionPointIn(): + for connection in instance.getconnectionPointIn(): connector = {} - connector["position"] = connection.getRelPosition() + connector["position"] = connection.getrelPositionXY() connector["links"] = [] - connections = connection.getConnections() + connections = connection.getconnections() if connections: - for link in connection.getConnections(): - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + for link in connection.getconnections(): + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} connector["links"].append(dic) infos["connectors"].append(connector) - elif isinstance(instance, plcopen.contact): - infos["name"] = instance.getVariable() + elif isinstance(instance, plcopen.ldObjects_contact): + infos["name"] = instance.getvariable() infos["type"] = "contact" - executionOrder = instance.getExecutionOrderId() + executionOrder = instance.getexecutionOrderId() if executionOrder is not None: infos["executionOrder"] = executionOrder else: infos["executionOrder"] = 0 - infos["negated"] = instance.getNegated() - infos["edge"] = instance.getContactEdge() + infos["negated"] = instance.getnegated() + infos["edge"] = instance.getedge() infos["connectors"] = {"input":{},"output":{}} - infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition() + infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY() infos["connectors"]["input"]["links"] = [] - connections = instance.connectionPointIn.getConnections() + connections = instance.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} infos["connectors"]["input"]["links"].append(dic) - infos["connectors"]["output"]["position"] = instance.connectionPointOut.getRelPosition() - elif isinstance(instance, plcopen.coil): - infos["name"] = instance.getVariable() + infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY() + elif isinstance(instance, plcopen.ldObjects_coil): + infos["name"] = instance.getvariable() infos["type"] = "coil" - executionOrder = instance.getExecutionOrderId() + executionOrder = instance.getexecutionOrderId() if executionOrder is not None: infos["executionOrder"] = executionOrder else: infos["executionOrder"] = 0 - infos["negated"] = instance.getNegated() - infos["storage"] = instance.getCoilStorage() + infos["negated"] = instance.getnegated() + infos["storage"] = instance.getstorage() infos["connectors"] = {"input":{},"output":{}} - infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition() + infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY() infos["connectors"]["input"]["links"] = [] - connections = instance.connectionPointIn.getConnections() + connections = instance.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} infos["connectors"]["input"]["links"].append(dic) - infos["connectors"]["output"]["position"] = instance.connectionPointOut.getRelPosition() - elif isinstance(instance, plcopen.step): - infos["name"] = instance.getName() + infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY() + elif isinstance(instance, plcopen.sfcObjects_step): + infos["name"] = instance.getname() infos["type"] = "step" - infos["initial"] = instance.getInitialStep() + infos["initial"] = instance.getinitialStep() infos["connectors"] = {} if instance.connectionPointIn: infos["connectors"]["input"] = {} - infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition() + infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY() infos["connectors"]["input"]["links"] = [] - connections = instance.connectionPointIn.getConnections() + connections = instance.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} infos["connectors"]["input"]["links"].append(dic) if instance.connectionPointOut: - infos["connectors"]["output"] = {"position" : instance.connectionPointOut.getRelPosition()} + infos["connectors"]["output"] = {"position" : instance.connectionPointOut.getrelPositionXY()} if instance.connectionPointOutAction: - infos["connectors"]["action"] = {"position" : instance.connectionPointOutAction.getRelPosition()} - elif isinstance(instance, plcopen.transition): + infos["connectors"]["action"] = {"position" : instance.connectionPointOutAction.getrelPositionXY()} + elif isinstance(instance, plcopen.sfcObjects_transition): infos["type"] = "transition" - condition = instance.getConditionContent() - priority = instance.getPriority() + condition = instance.getconditionContent() + priority = instance.getpriority() if priority == None: infos["priority"] = 0 else: infos["priority"] = priority infos["condition_type"] = condition["type"] infos["connectors"] = {"input":{},"output":{}} - infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition() + infos["connectors"]["input"]["position"] = instance.connectionPointIn.getrelPositionXY() infos["connectors"]["input"]["links"] = [] - connections = instance.connectionPointIn.getConnections() + connections = instance.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} infos["connectors"]["input"]["links"].append(dic) - infos["connectors"]["output"]["position"] = instance.connectionPointOut.getRelPosition() + infos["connectors"]["output"]["position"] = instance.connectionPointOut.getrelPositionXY() if infos["condition_type"] == "connection": infos["connectors"]["connection"] = {} infos["connectors"]["connection"]["links"] = [] - connections = instance.getConnections() + connections = instance.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} infos["connectors"]["connection"]["links"].append(dic) infos["condition"] = None else: infos["condition"] = condition["value"] - elif isinstance(instance, (plcopen.selectionDivergence, plcopen.simultaneousDivergence)): - if isinstance(instance, plcopen.selectionDivergence): + elif isinstance(instance, (plcopen.sfcObjects_selectionDivergence, plcopen.sfcObjects_simultaneousDivergence)): + if isinstance(instance, plcopen.sfcObjects_selectionDivergence): infos["type"] = "selectionDivergence" else: infos["type"] = "simultaneousDivergence" infos["connectors"] = {"inputs":[],"outputs":[]} connector = {} - connector["position"] = instance.connectionPointIn.getRelPosition() + connector["position"] = instance.connectionPointIn.getrelPositionXY() connector["links"] = [] - connections = instance.connectionPointIn.getConnections() + connections = instance.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} connector["links"].append(dic) infos["connectors"]["inputs"].append(connector) - for sequence in instance.getConnectionPointOut(): + for sequence in instance.getconnectionPointOut(): connector = {} - connector["position"] = sequence.getRelPosition() + connector["position"] = sequence.getrelPositionXY() infos["connectors"]["outputs"].append(connector) - elif isinstance(instance, (plcopen.selectionConvergence, plcopen.simultaneousConvergence)): - if isinstance(instance, plcopen.selectionConvergence): + elif isinstance(instance, (plcopen.sfcObjects_selectionConvergence, plcopen.sfcObjects_simultaneousConvergence)): + if isinstance(instance, plcopen.sfcObjects_selectionConvergence): infos["type"] = "selectionConvergence" else: infos["type"] = "simultaneousConvergence" infos["connectors"] = {"inputs":[],"outputs":[]} - for sequence in instance.getConnectionPointIn(): + for sequence in instance.getconnectionPointIn(): connector = {} - connector["position"] = sequence.getRelPosition() + connector["position"] = sequence.getrelPositionXY() connector["links"] = [] - connections = sequence.getConnections() + connections = sequence.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} connector["links"].append(dic) infos["connectors"]["inputs"].append(connector) connector = {} - connector["position"] = instance.connectionPointOut.getRelPosition() + connector["position"] = instance.connectionPointOut.getrelPositionXY() infos["connectors"]["outputs"].append(connector) - elif isinstance(instance, plcopen.jumpStep): + elif isinstance(instance, plcopen.sfcObjects_jumpStep): infos["type"] = "jump" - infos["target"] = instance.getTargetName() + infos["target"] = instance.gettargetName() infos["connector"] = {} - infos["connector"]["position"] = instance.connectionPointIn.getRelPosition() + infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY() infos["connector"]["links"] = [] - connections = instance.connectionPointIn.getConnections() + connections = instance.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} infos["connector"]["links"].append(dic) - elif isinstance(instance, plcopen.actionBlock): + elif isinstance(instance, plcopen.commonObjects_actionBlock): infos["type"] = "actionBlock" - infos["actions"] = instance.getActions() + infos["actions"] = instance.getactions() infos["connector"] = {} - infos["connector"]["position"] = instance.connectionPointIn.getRelPosition() + infos["connector"]["position"] = instance.connectionPointIn.getrelPositionXY() infos["connector"]["links"] = [] - connections = instance.connectionPointIn.getConnections() + connections = instance.connectionPointIn.getconnections() if connections: for link in connections: - dic = {"refLocalId":link.getRefLocalId(),"points":link.getPoints(),"formalParameter":link.getFormalParameter()} + dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()} infos["connector"]["links"].append(dic) return infos return False @@ -1612,24 +1611,24 @@ def ClearEditedElementExecutionOrder(self, tagname): element = self.GetEditedElement(tagname) if element is not None: - element.resetExecutionOrder() + element.resetexecutionOrder() def ResetEditedElementExecutionOrder(self, tagname): element = self.GetEditedElement(tagname) if element is not None: - element.compileExecutionOrder() + element.compileexecutionOrder() # Return the variable type of the given pou def GetEditedElementVarValueType(self, tagname, varname): words = tagname.split("::") if words[0] in ["P","T","A"]: - pou = self.Project.getPou(words[1]) - for type, varlist in pou.getVars(): - for var in varlist.getVariable(): - if var.getName() == varname: - vartype_content = var.getType().getContent() + pou = self.Project.getpou(words[1]) + for type, varlist in pou.getvars(): + for var in varlist.getvariable(): + if var.getname() == varname: + vartype_content = var.gettype().getcontent() if vartype_content["name"] == "derived": - return vartype_content["value"].getName() + return vartype_content["value"].getname() elif vartype_content["name"] in ["string", "wstring"]: return vartype_content["name"].upper() else: @@ -1647,93 +1646,93 @@ result = wire.GetConnectedInfos(0) if result != None: refLocalId, formalParameter = result - connection.addConnection() - connection.setConnectionId(idx, refLocalId) - connection.setConnectionPoints(idx, points) + connection.addconnection() + connection.setconnectionId(idx, refLocalId) + connection.setconnectionPoints(idx, points) if formalParameter != "": - connection.setConnectionParameter(idx, formalParameter) + connection.setconnectionParameter(idx, formalParameter) else: - connection.setConnectionParameter(idx, None) + connection.setconnectionParameter(idx, None) idx += 1 def AddEditedElementPouVar(self, tagname, type, name): words = tagname.split("::") if words[0] in ['P', 'T', 'A']: - pou = self.Project.getPou(words[1]) - pou.addPouVar(type, name) + pou = self.Project.getpou(words[1]) + pou.addpouVar(type, name) def ChangeEditedElementPouVar(self, tagname, old_type, old_name, new_type, new_name): words = tagname.split("::") if words[0] in ['P', 'T', 'A']: - pou = self.Project.getPou(words[1]) - pou.changePouVar(old_type, old_name, new_type, new_name) + pou = self.Project.getpou(words[1]) + pou.changepouVar(old_type, old_name, new_type, new_name) def AddEditedElementBlock(self, tagname, id, blocktype, blockname = None): element = self.GetEditedElement(tagname) if element is not None: - block = plcopen.block() - block.setLocalId(id) - block.setTypeName(blocktype) + block = plcopen.fbdObjects_block() + block.setlocalId(id) + block.settypeName(blocktype) blocktype_infos = GetBlockType(blocktype) if blocktype_infos["type"] != "function" and blockname is not None: - block.setInstanceName(blockname) + block.setinstanceName(blockname) self.AddEditedElementPouVar(tagname, blocktype, blockname) - element.addInstance("block", block) + element.addinstance("block", block) self.RefreshPouUsingTree() def SetEditedElementBlockInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - block = element.getInstance(id) - blocktype = infos.get("type", block.getTypeName()) + block = element.getinstance(id) + blocktype = infos.get("type", block.gettypeName()) blocktype_infos = GetBlockType(blocktype) if blocktype_infos["type"] != "function": if "name" in infos or "type" in infos: - old_name = block.getInstanceName() - old_type = block.getTypeName() + old_name = block.getinstanceName() + old_type = block.gettypeName() new_name = infos.get("name", old_name) new_type = infos.get("type", old_type) self.ChangeEditedElementPouVar(tagname, old_type, old_name, new_type, new_name) for param, value in infos.items(): if param == "name": - block.setInstanceName(value) + block.setinstanceName(value) elif param == "type": - block.setTypeName(value) - elif param == "executionOrder" and block.getExecutionOrderId() != value: - self.GetEditedElement(tagname).setElementExecutionOrder(block, value) + block.settypeName(value) + elif param == "executionOrder" and block.getexecutionOrderId() != value: + self.GetEditedElement(tagname).setelementExecutionOrder(block, value) elif param == "height": - block.setHeight(value) + block.setheight(value) elif param == "width": - block.setWidth(value) + block.setwidth(value) elif param == "x": - block.setX(value) + block.setx(value) elif param == "y": - block.setY(value) + block.sety(value) elif param == "connectors": - block.inputVariables.setVariable([]) - block.outputVariables.setVariable([]) + block.inputVariables.setvariable([]) + block.outputVariables.setvariable([]) for connector in value["inputs"]: variable = plcopen.inputVariables_variable() - variable.setFormalParameter(connector.GetName()) + variable.setformalParameter(connector.GetName()) if connector.IsNegated(): - variable.setNegated(True) + variable.setnegated(True) if connector.GetEdge() != "none": - variable.setConnectorEdge(connector.GetEdge()) + variable.setedge(connector.GetEdge()) position = connector.GetRelPosition() - variable.connectionPointIn.setRelPosition(position.x, position.y) + variable.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(variable.connectionPointIn, connector) - block.inputVariables.appendVariable(variable) + block.inputVariables.appendvariable(variable) for connector in value["outputs"]: variable = plcopen.outputVariables_variable() - variable.setFormalParameter(connector.GetName()) + variable.setformalParameter(connector.GetName()) if connector.IsNegated(): - variable.setNegated(True) + variable.setnegated(True) if connector.GetEdge() != "none": - variable.setConnectorEdge(connector.GetEdge()) + variable.setedge(connector.GetEdge()) position = connector.GetRelPosition() - variable.addConnectionPointOut() - variable.connectionPointOut.setRelPosition(position.x, position.y) - block.outputVariables.appendVariable(variable) + variable.addconnectionPointOut() + variable.connectionPointOut.setrelPositionXY(position.x, position.y) + block.outputVariables.appendvariable(variable) self.RefreshPouUsingTree() def AddEditedElementVariable(self, tagname, id, type): @@ -1741,66 +1740,66 @@ if element is not None: if type == INPUT: name = "inVariable" - variable = plcopen.inVariable() + variable = plcopen.fbdObjects_inVariable() elif type == OUTPUT: name = "outVariable" - variable = plcopen.outVariable() + variable = plcopen.fbdObjects_outVariable() elif type == INOUT: name = "inOutVariable" - variable = plcopen.inOutVariable() - variable.setLocalId(id) - element.addInstance(name, variable) + variable = plcopen.fbdObjects_inOutVariable() + variable.setlocalId(id) + element.addinstance(name, variable) def SetEditedElementVariableInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - variable = element.getInstance(id) + variable = element.getinstance(id) for param, value in infos.items(): if param == "name": - variable.setExpression(value) - elif param == "executionOrder" and variable.getExecutionOrderId() != value: - self.GetEditedElement(tagname).setElementExecutionOrder(variable, value) + variable.setexpression(value) + elif param == "executionOrder" and variable.getexecutionOrderId() != value: + self.GetEditedElement(tagname).setelementExecutionOrder(variable, value) elif param == "height": - variable.setHeight(value) + variable.setheight(value) elif param == "width": - variable.setWidth(value) + variable.setwidth(value) elif param == "x": - variable.setX(value) + variable.setx(value) elif param == "y": - variable.setY(value) + variable.sety(value) elif param == "connectors": - if isinstance(variable, plcopen.inVariable): + if isinstance(variable, plcopen.fbdObjects_inVariable): if value["output"].IsNegated(): - variable.setNegated(True) + variable.setnegated(True) if value["output"].GetEdge() != "none": - variable.setConnectorEdge(value["output"].GetEdge()) + variable.setedge(value["output"].GetEdge()) position = value["output"].GetRelPosition() - variable.addConnectionPointOut() - variable.connectionPointOut.setRelPosition(position.x, position.y) - elif isinstance(variable, plcopen.outVariable): + variable.addconnectionPointOut() + variable.connectionPointOut.setrelPositionXY(position.x, position.y) + elif isinstance(variable, plcopen.fbdObjects_outVariable): if value["input"].IsNegated(): - variable.setNegated(True) + variable.setnegated(True) if value["input"].GetEdge() != "none": - variable.setConnectorEdge(value["input"].GetEdge()) + variable.setedge(value["input"].GetEdge()) position = value["input"].GetRelPosition() - variable.addConnectionPointIn() - variable.connectionPointIn.setRelPosition(position.x, position.y) + variable.addconnectionPointIn() + variable.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(variable.connectionPointIn, value["input"]) - elif isinstance(variable, plcopen.inOutVariable): + elif isinstance(variable, plcopen.fbdObjects_inOutVariable): if value["input"].IsNegated(): - variable.setNegatedIn(True) + variable.setnegatedIn(True) if value["input"].GetEdge() != "none": - variable.setInputEdge(value["input"].GetEdge()) + variable.setedgeIn(value["input"].GetEdge()) if value["output"].IsNegated(): - variable.setNegatedOut(True) + variable.setnegatedOut(True) if value["output"].GetEdge() != "none": - variable.setOutputEdge(value["output"].GetEdge()) + variable.setedgeOut(value["output"].GetEdge()) position = value["output"].GetRelPosition() - variable.addConnectionPointOut() - variable.connectionPointOut.setRelPosition(position.x, position.y) + variable.addconnectionPointOut() + variable.connectionPointOut.setrelPositionXY(position.x, position.y) position = value["input"].GetRelPosition() - variable.addConnectionPointIn() - variable.connectionPointIn.setRelPosition(position.x, position.y) + variable.addconnectionPointIn() + variable.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(variable.connectionPointIn, value["input"]) def AddEditedElementConnection(self, tagname, id, type): @@ -1808,282 +1807,282 @@ if element is not None: if type == CONNECTOR: name = "connector" - connection = plcopen.connector() + connection = plcopen.commonObjects_connector() elif type == CONTINUATION: name = "continuation" - connection = plcopen.continuation() - connection.setLocalId(id) - element.addInstance(name, connection) + connection = plcopen.commonObjects_continuation() + connection.setlocalId(id) + element.addinstance(name, connection) def SetEditedElementConnectionInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - connection = element.getInstance(id) + connection = element.getinstance(id) for param, value in infos.items(): if param == "name": - connection.setName(value) + connection.setname(value) elif param == "height": - connection.setHeight(value) + connection.setheight(value) elif param == "width": - connection.setWidth(value) + connection.setwidth(value) elif param == "x": - connection.setX(value) + connection.setx(value) elif param == "y": - connection.setY(value) + connection.sety(value) elif param == "connector": position = value.GetRelPosition() - if isinstance(connection, plcopen.continuation): - connection.addConnectionPointOut() - connection.connectionPointOut.setRelPosition(position.x, position.y) - elif isinstance(connection, plcopen.connector): - connection.addConnectionPointIn() - connection.connectionPointIn.setRelPosition(position.x, position.y) + if isinstance(connection, plcopen.commonObjects_continuation): + connection.addconnectionPointOut() + connection.connectionPointOut.setrelPositionXY(position.x, position.y) + elif isinstance(connection, plcopen.commonObjects_connector): + connection.addconnectionPointIn() + connection.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(connection.connectionPointIn, value) def AddEditedElementComment(self, tagname, id): element = self.GetEditedElement(tagname) if element is not None: - comment = plcopen.comment() - comment.setLocalId(id) - element.addInstance("comment", comment) + comment = plcopen.commonObjects_comment() + comment.setlocalId(id) + element.addinstance("comment", comment) def SetEditedElementCommentInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - comment = element.getInstance(id) + comment = element.getinstance(id) for param, value in infos.items(): if param == "content": - comment.setContentText(value) + comment.setcontentText(value) elif param == "height": - comment.setHeight(value) + comment.setheight(value) elif param == "width": - comment.setWidth(value) + comment.setwidth(value) elif param == "x": - comment.setX(value) + comment.setx(value) elif param == "y": - comment.setY(value) + comment.sety(value) def AddEditedElementPowerRail(self, tagname, id, type): element = self.GetEditedElement(tagname) if element is not None: if type == LEFTRAIL: name = "leftPowerRail" - powerrail = plcopen.leftPowerRail() + powerrail = plcopen.ldObjects_leftPowerRail() elif type == RIGHTRAIL: name = "rightPowerRail" - powerrail = plcopen.rightPowerRail() - powerrail.setLocalId(id) - element.addInstance(name, powerrail) + powerrail = plcopen.ldObjects_rightPowerRail() + powerrail.setlocalId(id) + element.addinstance(name, powerrail) def SetEditedElementPowerRailInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - powerrail = element.getInstance(id) + powerrail = element.getinstance(id) for param, value in infos.items(): if param == "height": - powerrail.setHeight(value) + powerrail.setheight(value) elif param == "width": - powerrail.setWidth(value) + powerrail.setwidth(value) elif param == "x": - powerrail.setX(value) + powerrail.setx(value) elif param == "y": - powerrail.setY(value) + powerrail.sety(value) elif param == "connectors": - if isinstance(powerrail, plcopen.leftPowerRail): - powerrail.setConnectionPointOut([]) + if isinstance(powerrail, plcopen.ldObjects_leftPowerRail): + powerrail.setconnectionPointOut([]) for connector in value: position = connector.GetRelPosition() connection = plcopen.leftPowerRail_connectionPointOut() - connection.setRelPosition(position.x, position.y) + connection.setrelPositionXY(position.x, position.y) powerrail.connectionPointOut.append(connection) - elif isinstance(powerrail, plcopen.rightPowerRail): - powerrail.setConnectionPointIn([]) + elif isinstance(powerrail, plcopen.ldObjects_rightPowerRail): + powerrail.setconnectionPointIn([]) for connector in value: position = connector.GetRelPosition() connection = plcopen.connectionPointIn() - connection.setRelPosition(position.x, position.y) + connection.setrelPositionXY(position.x, position.y) self.SetConnectionWires(connection, connector) powerrail.connectionPointIn.append(connection) def AddEditedElementContact(self, tagname, id): element = self.GetEditedElement(tagname) if element is not None: - contact = plcopen.contact() - contact.setLocalId(id) - element.addInstance("contact", contact) + contact = plcopen.ldObjects_contact() + contact.setlocalId(id) + element.addinstance("contact", contact) def SetEditedElementContactInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - contact = element.getInstance(id) + contact = element.getinstance(id) for param, value in infos.items(): if param == "name": - contact.setVariable(value) + contact.setvariable(value) elif param == "type": if value == CONTACT_NORMAL: - contact.setNegated(False) - contact.setContactEdge("none") + contact.setnegated(False) + contact.setedge("none") elif value == CONTACT_REVERSE: - contact.setNegated(True) - contact.setContactEdge("none") + contact.setnegated(True) + contact.setedge("none") elif value == CONTACT_RISING: - contact.setNegated(False) - contact.setContactEdge("rising") + contact.setnegated(False) + contact.setedge("rising") elif value == CONTACT_FALLING: - contact.setNegated(False) - contact.setContactEdge("falling") + contact.setnegated(False) + contact.setedge("falling") elif param == "height": - contact.setHeight(value) + contact.setheight(value) elif param == "width": - contact.setWidth(value) + contact.setwidth(value) elif param == "x": - contact.setX(value) + contact.setx(value) elif param == "y": - contact.setY(value) + contact.sety(value) elif param == "connectors": input_connector = value["input"] position = input_connector.GetRelPosition() - contact.addConnectionPointIn() - contact.connectionPointIn.setRelPosition(position.x, position.y) + contact.addconnectionPointIn() + contact.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(contact.connectionPointIn, input_connector) output_connector = value["output"] position = output_connector.GetRelPosition() - contact.addConnectionPointOut() - contact.connectionPointOut.setRelPosition(position.x, position.y) + contact.addconnectionPointOut() + contact.connectionPointOut.setrelPositionXY(position.x, position.y) def AddEditedElementCoil(self, tagname, id): element = self.GetEditedElement(tagname) if element is not None: - coil = plcopen.coil() - coil.setLocalId(id) - element.addInstance("coil", coil) + coil = plcopen.ldObjects_coil() + coil.setlocalId(id) + element.addinstance("coil", coil) def SetEditedElementCoilInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - coil = element.getInstance(id) + coil = element.getinstance(id) for param, value in infos.items(): if param == "name": - coil.setVariable(value) + coil.setvariable(value) elif param == "type": if value == COIL_NORMAL: - coil.setNegated(False) - coil.setCoilStorage("none") + coil.setnegated(False) + coil.setstorage("none") elif value == COIL_REVERSE: - coil.setNegated(True) - coil.setCoilStorage("none") + coil.setnegated(True) + coil.setstorage("none") elif value == COIL_SET: - coil.setNegated(False) - coil.setCoilStorage("set") + coil.setnegated(False) + coil.setstorage("set") elif value == COIL_RESET: - coil.setNegated(False) - coil.setCoilStorage("reset") + coil.setnegated(False) + coil.setstorage("reset") elif param == "height": - coil.setHeight(value) + coil.setheight(value) elif param == "width": - coil.setWidth(value) + coil.setwidth(value) elif param == "x": - coil.setX(value) + coil.setx(value) elif param == "y": - coil.setY(value) + coil.sety(value) elif param == "connectors": input_connector = value["input"] position = input_connector.GetRelPosition() - coil.addConnectionPointIn() - coil.connectionPointIn.setRelPosition(position.x, position.y) + coil.addconnectionPointIn() + coil.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(coil.connectionPointIn, input_connector) output_connector = value["output"] position = output_connector.GetRelPosition() - coil.addConnectionPointOut() - coil.connectionPointOut.setRelPosition(position.x, position.y) + coil.addconnectionPointOut() + coil.connectionPointOut.setrelPositionXY(position.x, position.y) def AddEditedElementStep(self, tagname, id): element = self.GetEditedElement(tagname) if element is not None: - step = plcopen.step() - step.setLocalId(id) - element.addInstance("step", step) + step = plcopen.sfcObjects_step() + step.setlocalId(id) + element.addinstance("step", step) def SetEditedElementStepInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - step = element.getInstance(id) + step = element.getinstance(id) for param, value in infos.items(): if param == "name": - step.setName(value) + step.setname(value) elif param == "initial": - step.setInitialStep(value) + step.setinitialStep(value) elif param == "height": - step.setHeight(value) + step.setheight(value) elif param == "width": - step.setWidth(value) + step.setwidth(value) elif param == "x": - step.setX(value) + step.setx(value) elif param == "y": - step.setY(value) + step.sety(value) elif param == "connectors": input_connector = value["input"] if input_connector: position = input_connector.GetRelPosition() - step.addConnectionPointIn() - step.connectionPointIn.setRelPosition(position.x, position.y) + step.addconnectionPointIn() + step.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(step.connectionPointIn, input_connector) else: - step.deleteConnectionPointIn() + step.deleteconnectionPointIn() output_connector = value["output"] if output_connector: position = output_connector.GetRelPosition() - step.addConnectionPointOut() - step.connectionPointOut.setRelPosition(position.x, position.y) - else: - step.deleteConnectionPointOut() + step.addconnectionPointOut() + step.connectionPointOut.setrelPositionXY(position.x, position.y) + else: + step.deleteconnectionPointOut() action_connector = value["action"] if action_connector: position = action_connector.GetRelPosition() - step.addConnectionPointOutAction() - step.connectionPointOutAction.setRelPosition(position.x, position.y) - else: - step.deleteConnectionPointOutAction() + step.addconnectionPointOutAction() + step.connectionPointOutAction.setrelPositionXY(position.x, position.y) + else: + step.deleteconnectionPointOutAction() def AddEditedElementTransition(self, tagname, id): element = self.GetEditedElement(tagname) if element is not None: - transition = plcopen.transition() - transition.setLocalId(id) - element.addInstance("transition", transition) + transition = plcopen.sfcObjects_transition() + transition.setlocalId(id) + element.addinstance("transition", transition) def SetEditedElementTransitionInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - transition = element.getInstance(id) + transition = element.getinstance(id) for param, value in infos.items(): if param == "type" and value != "connection": - transition.setConditionContent(value, infos["condition"]) + transition.setconditionContent(value, infos["condition"]) elif param == "height": - transition.setHeight(value) + transition.setheight(value) elif param == "width": - transition.setWidth(value) + transition.setwidth(value) elif param == "x": - transition.setX(value) + transition.setx(value) elif param == "y": - transition.setY(value) + transition.sety(value) elif param == "priority": if value != 0: - transition.setPriority(value) - else: - transition.setPriority(None) + transition.setpriority(value) + else: + transition.setpriority(None) elif param == "connectors": input_connector = value["input"] position = input_connector.GetRelPosition() - transition.addConnectionPointIn() - transition.connectionPointIn.setRelPosition(position.x, position.y) + transition.addconnectionPointIn() + transition.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(transition.connectionPointIn, input_connector) output_connector = value["output"] position = output_connector.GetRelPosition() - transition.addConnectionPointOut() - transition.connectionPointOut.setRelPosition(position.x, position.y) + transition.addconnectionPointOut() + transition.connectionPointOut.setrelPositionXY(position.x, position.y) if infos.get("type", None) == "connection": - transition.setConditionContent("connection", None) + transition.setconditionContent("connection", None) connection_connector = value["connection"] self.SetConnectionWires(transition, connection_connector) @@ -2092,130 +2091,130 @@ if element is not None: if type == SELECTION_DIVERGENCE: name = "selectionDivergence" - divergence = plcopen.selectionDivergence() + divergence = plcopen.sfcObjects_selectionDivergence() elif type == SELECTION_CONVERGENCE: name = "selectionConvergence" - divergence = plcopen.selectionConvergence() + divergence = plcopen.sfcObjects_selectionConvergence() elif type == SIMULTANEOUS_DIVERGENCE: name = "simultaneousDivergence" - divergence = plcopen.simultaneousDivergence() + divergence = plcopen.sfcObjects_simultaneousDivergence() elif type == SIMULTANEOUS_CONVERGENCE: name = "simultaneousConvergence" - divergence = plcopen.simultaneousConvergence() - divergence.setLocalId(id) - element.addInstance(name, divergence) + divergence = plcopen.sfcObjects_simultaneousConvergence() + divergence.setlocalId(id) + element.addinstance(name, divergence) def SetEditedElementDivergenceInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - divergence = element.getInstance(id) + divergence = element.getinstance(id) for param, value in infos.items(): if param == "height": - divergence.setHeight(value) + divergence.setheight(value) elif param == "width": - divergence.setWidth(value) + divergence.setwidth(value) elif param == "x": - divergence.setX(value) + divergence.setx(value) elif param == "y": - divergence.setY(value) + divergence.sety(value) elif param == "connectors": input_connectors = value["inputs"] - if isinstance(divergence, (plcopen.selectionDivergence, plcopen.simultaneousDivergence)): + if isinstance(divergence, (plcopen.sfcObjects_selectionDivergence, plcopen.sfcObjects_simultaneousDivergence)): position = input_connectors[0].GetRelPosition() - divergence.addConnectionPointIn() - divergence.connectionPointIn.setRelPosition(position.x, position.y) + divergence.addconnectionPointIn() + divergence.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(divergence.connectionPointIn, input_connectors[0]) else: - divergence.setConnectionPointIn([]) + divergence.setconnectionPointIn([]) for input_connector in input_connectors: position = input_connector.GetRelPosition() - if isinstance(divergence, plcopen.selectionConvergence): + if isinstance(divergence, plcopen.sfcObjects_selectionConvergence): connection = plcopen.selectionConvergence_connectionPointIn() else: connection = plcopen.connectionPointIn() - connection.setRelPosition(position.x, position.y) + connection.setrelPositionXY(position.x, position.y) self.SetConnectionWires(connection, input_connector) - divergence.appendConnectionPointIn(connection) + divergence.appendconnectionPointIn(connection) output_connectors = value["outputs"] - if isinstance(divergence, (plcopen.selectionConvergence, plcopen.simultaneousConvergence)): + if isinstance(divergence, (plcopen.sfcObjects_selectionConvergence, plcopen.sfcObjects_simultaneousConvergence)): position = output_connectors[0].GetRelPosition() - divergence.addConnectionPointOut() - divergence.connectionPointOut.setRelPosition(position.x, position.y) - else: - divergence.setConnectionPointOut([]) + divergence.addconnectionPointOut() + divergence.connectionPointOut.setrelPositionXY(position.x, position.y) + else: + divergence.setconnectionPointOut([]) for output_connector in output_connectors: position = output_connector.GetRelPosition() - if isinstance(divergence, plcopen.selectionDivergence): + if isinstance(divergence, plcopen.sfcObjects_selectionDivergence): connection = plcopen.selectionDivergence_connectionPointOut() else: connection = plcopen.simultaneousDivergence_connectionPointOut() - connection.setRelPosition(position.x, position.y) - divergence.appendConnectionPointOut(connection) + connection.setrelPositionXY(position.x, position.y) + divergence.appendconnectionPointOut(connection) def AddEditedElementJump(self, tagname, id): element = self.GetEditedElement(tagname) if element is not None: - jump = plcopen.jumpStep() - jump.setLocalId(id) - element.addInstance("jumpStep", jump) + jump = plcopen.sfcObjects_jumpStep() + jump.setlocalId(id) + element.addinstance("jumpStep", jump) def SetEditedElementJumpInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - jump = element.getInstance(id) + jump = element.getinstance(id) for param, value in infos.items(): if param == "target": - jump.setTargetName(value) + jump.settargetName(value) elif param == "height": - jump.setHeight(value) + jump.setheight(value) elif param == "width": - jump.setWidth(value) + jump.setwidth(value) elif param == "x": - jump.setX(value) + jump.setx(value) elif param == "y": - jump.setY(value) + jump.sety(value) elif param == "connector": position = value.GetRelPosition() - jump.addConnectionPointIn() - jump.connectionPointIn.setRelPosition(position.x, position.y) + jump.addconnectionPointIn() + jump.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(jump.connectionPointIn, value) def AddEditedElementActionBlock(self, tagname, id): element = self.GetEditedElement(tagname) if element is not None: - actionBlock = plcopen.actionBlock() - actionBlock.setLocalId(id) - element.addInstance("actionBlock", actionBlock) + actionBlock = plcopen.commonObjects_actionBlock() + actionBlock.setlocalId(id) + element.addinstance("actionBlock", actionBlock) def SetEditedElementActionBlockInfos(self, tagname, id, infos): element = self.GetEditedElement(tagname) if element is not None: - actionBlock = element.getInstance(id) + actionBlock = element.getinstance(id) for param, value in infos.items(): if param == "actions": - actionBlock.setActions(value) + actionBlock.setactions(value) elif param == "height": - actionBlock.setHeight(value) + actionBlock.setheight(value) elif param == "width": - actionBlock.setWidth(value) + actionBlock.setwidth(value) elif param == "x": - actionBlock.setX(value) + actionBlock.setx(value) elif param == "y": - actionBlock.setY(value) + actionBlock.sety(value) elif param == "connector": position = value.GetRelPosition() - actionBlock.addConnectionPointIn() - actionBlock.connectionPointIn.setRelPosition(position.x, position.y) + actionBlock.addconnectionPointIn() + actionBlock.connectionPointIn.setrelPositionXY(position.x, position.y) self.SetConnectionWires(actionBlock.connectionPointIn, value) def RemoveEditedElementInstance(self, tagname, id): element = self.GetEditedElement(tagname) if element is not None: - instance = element.getInstance(id) - if isinstance(instance, plcopen.block): - blocktype = instance.getTypeName() - element.removePouVar(blocktype, instance.getInstanceName()) - element.removeInstance(id) + instance = element.getinstance(id) + if isinstance(instance, plcopen.fbdObjects_block): + blocktype = instance.gettypeName() + element.removepouVar(blocktype, instance.getinstanceName()) + element.removeinstance(id) self.RefreshPouUsingTree() def GetEditedResourceVariables(self, tagname): @@ -2232,14 +2231,14 @@ def SetEditedResourceInfos(self, tagname, tasks, instances): resource = self.GetEditedElement(tagname) if resource is not None: - resource.setTask([]) - resource.setPouInstance([]) + resource.settask([]) + resource.setpouInstance([]) task_list = {} for task in tasks: new_task = plcopen.resource_task() - new_task.setName(task["Name"]) + new_task.setname(task["Name"]) if task["Single"] != "": - new_task.setSingle(task["Single"]) + new_task.setsingle(task["Single"]) result = duration_model.match(task["Interval"]).groups() if reduce(lambda x, y: x or y != None, result): values = [] @@ -2249,36 +2248,36 @@ else: values.append(0) values.append(int(float(result[-1]) * 1000)) - new_task.setInterval(time(*values)) - new_task.priority.setValue(int(task["Priority"])) + new_task.setinterval(time(*values)) + new_task.setpriority(int(task["Priority"])) if task["Name"] != "": task_list[task["Name"]] = new_task - resource.appendTask(new_task) + resource.appendtask(new_task) for instance in instances: new_instance = plcopen.pouInstance() - new_instance.setName(instance["Name"]) - new_instance.setType(instance["Type"]) + new_instance.setname(instance["Name"]) + new_instance.settype(instance["Type"]) if instance["Task"] != "": - task_list[instance["Task"]].appendPouInstance(new_instance) + task_list[instance["Task"]].appendpouInstance(new_instance) else: - resource.appendPouInstance(new_instance) + resource.appendpouInstance(new_instance) def GetEditedResourceInfos(self, tagname): resource = self.GetEditedElement(tagname) if resource is not None: - tasks = resource.getTask() - instances = resource.getPouInstance() + tasks = resource.gettask() + instances = resource.getpouInstance() tasks_data = [] instances_data = [] for task in tasks: new_task = {} - new_task["Name"] = task.getName() - single = task.getSingle() + new_task["Name"] = task.getname() + single = task.getsingle() if single: new_task["Single"] = single else: new_task["Single"] = "" - interval = task.getInterval() + interval = task.getinterval() if interval: text = "" if interval.hour != 0: @@ -2295,39 +2294,31 @@ new_task["Interval"] = text else: new_task["Interval"] = "" - new_task["Priority"] = str(task.priority.getValue()) + new_task["Priority"] = str(task.getpriority()) tasks_data.append(new_task) - for instance in task.getPouInstance(): + for instance in task.getpouInstance(): new_instance = {} - new_instance["Name"] = instance.getName() - new_instance["Type"] = instance.getType() - new_instance["Task"] = task.getName() + new_instance["Name"] = instance.getname() + new_instance["Type"] = instance.gettype() + new_instance["Task"] = task.getname() instances_data.append(new_instance) for instance in instances: new_instance = {} - new_instance["Name"] = instance.getName() - new_instance["Type"] = instance.getType() + new_instance["Name"] = instance.getname() + new_instance["Type"] = instance.gettype() new_instance["Task"] = "" instances_data.append(new_instance) return tasks_data, instances_data def OpenXMLFile(self, filepath): - if self.VerifyXML: - if sys: - sys.stdout = HolePseudoFile() - result = pyxsval.parseAndValidate(filepath, os.path.join(ScriptDirectory, "plcopen", "TC6_XML_V10_B.xsd")) - if sys: - sys.stdout = sys.__stdout__ - tree = result.getTree() - else: - xmlfile = open(filepath, 'r') - tree = minidom.parse(xmlfile) - xmlfile.close() + xmlfile = open(filepath, 'r') + tree = minidom.parse(xmlfile) + xmlfile.close() self.Project = plcopen.project() for child in tree.childNodes: if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "project": - self.Project.loadXMLTree(child) + self.Project.loadXMLTree(child, ["xmlns", "xmlns:xhtml", "xmlns:xsi", "xsi:schemaLocation"]) self.SetFilePath(filepath) self.ProjectBuffer = UndoBuffer(self.Copy(self.Project), True) self.Buffering = False @@ -2344,9 +2335,9 @@ if not filepath and self.FilePath == "": return False else: - contentheader = self.Project.getContentHeader() + contentheader = self.Project.getcontentHeader() contentheader["modificationDateTime"] = datetime(*localtime()[:6]) - self.Project.setContentHeader(contentheader) + self.Project.setcontentHeader(contentheader) text = "\n" extras = {"xmlns" : "http://www.plcopen.org/xml/tc6.xsd", @@ -2355,13 +2346,6 @@ "xsi:schemaLocation" : "http://www.plcopen.org/xml/tc6.xsd http://www.plcopen.org/xml/tc6.xsd"} text += self.Project.generateXMLText("project", 0, extras) - if self.VerifyXML: - if sys: - sys.stdout = HolePseudoFile() - pyxsval.parseAndValidateString(text, open(os.path.join(ScriptDirectory, "plcopen", "TC6_XML_V10_B.xsd"),"r").read()) - if sys: - sys.stdout = sys.__stdout__ - if filepath: xmlfile = open(filepath,"w") else: