plcopeneditor_history: comparison PLCControler.py

equal deleted inserted replaced

-:f7df265edd54
+:d8425712acef
 from PLCGenerator import *
 duration_model = re.compile("(?:([0-9]{1,2})h)?(?:([0-9]{1,2})m(?!s))?(?:([0-9]{1,2})s)?(?:([0-9]{1,3}(?:\.[0-9]*)?)ms)?")
 ITEMS_EDITABLE = [ITEM_PROJECT,
 ITEM_POU,
 ITEM_VARIABLE,
 ITEM_TRANSITION,
 ITEM_ACTION,
 ITEM_CONFIGURATION,
 ITEM_RESOURCE,
-ITEM_DATATYPE] = range(8)
+ITEM_DATATYPE
+] = range(8)
-ITEMS_UNEDITABLE=[ITEM_DATATYPES,
-ITEM_FUNCTION,
+ITEMS_UNEDITABLE = [ITEM_DATATYPES,
-ITEM_FUNCTIONBLOCK,
+ITEM_FUNCTION,
-ITEM_PROGRAM,
+ITEM_FUNCTIONBLOCK,
-ITEM_VAR_LOCAL,
+ITEM_PROGRAM,
+ITEM_TRANSITIONS,
+ITEM_ACTIONS,
+ITEM_CONFIGURATIONS,
+ITEM_RESOURCES,
+ITEM_PROPERTIES
+] = range(8, 17)
+ITEMS_VARIABLE = [ITEM_VAR_LOCAL,
 ITEM_VAR_GLOBAL,
 ITEM_VAR_EXTERNAL,
 ITEM_VAR_TEMP,
 ITEM_VAR_INPUT,
 ITEM_VAR_OUTPUT,
-ITEM_VAR_INOUT,
+ITEM_VAR_INOUT
-ITEM_TRANSITIONS,
+] = range(17, 24)
-ITEM_ACTIONS,
-ITEM_CONFIGURATIONS,
-ITEM_RESOURCES,
-ITEM_PROPERTIES,
-]=range(9,25)
 VAR_CLASS_INFOS = {"Local" :    (plcopen.interface_localVars,    ITEM_VAR_LOCAL),
 "Global" :   (plcopen.interface_globalVars,   ITEM_VAR_GLOBAL),
 "External" : (plcopen.interface_externalVars, ITEM_VAR_EXTERNAL),
 "Temp" :     (plcopen.interface_tempVars,     ITEM_VAR_TEMP),
 self.ProjectBuffer = None
 self.Buffering = False
 self.FilePath = ""
 self.FileName = ""
 self.ProgramChunks = []
+self.CurrentCompiledProject = None
 self.PluginTypes = []
 self.ProgramFilePath = ""
 def GetQualifierTypes(self):
 return plcopen.QualifierList
+def GetProject(self, debug = False):
+if debug and self.CurrentCompiledProject is not None:
+return self.CurrentCompiledProject
+else:
+return self.Project
 #-------------------------------------------------------------------------------
 #                         Project management functions
 #-------------------------------------------------------------------------------
 # Return if a project is opened
 def HasOpenedProject(self):
-return self.Project != None
+return self.Project is not None
 # Create a new project by replacing the current one
 def CreateNewProject(self, properties):
 # Create the project
 self.Project = plcopen.project()
 self.Project.setfileHeader(properties)
 self.Project.setcontentHeader(properties)
 self.SetFilePath("")
 # Initialize the project buffer
 self.ProjectBuffer = UndoBuffer(self.Copy(self.Project), False)
+self.ProgramChunks = []
+self.CurrentCompiledProject = None
 self.Buffering = False
 # Return project data type names
-def GetProjectDataTypeNames(self):
+def GetProjectDataTypeNames(self, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-return [datatype.getname() for datatype in self.Project.getdataTypes()]
+if project is not None:
+return [datatype.getname() for datatype in project.getdataTypes()]
 return []
 # Return project pou names
-def GetProjectPouNames(self):
+def GetProjectPouNames(self, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-return [pou.getname() for pou in self.Project.getpous()]
+if project is not None:
+return [pou.getname() for pou in project.getpous()]
 return []
 # Return project pou names
-def GetProjectConfigNames(self):
+def GetProjectConfigNames(self, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-return [config.getName() for config in self.Project.getconfigurations()]
+if project is not None:
+return [config.getName() for config in project.getconfigurations()]
 return []
 # Return project pou variables
-def GetProjectPouVariables(self, pou_name=None):
+def GetProjectPouVariables(self, pou_name = None, debug = False):
 variables = []
-for pou in self.Project.getpous():
+project = self.GetProject(debug)
-if not pou_name or pou_name == pou.getname():
+if project is not None:
-variables.extend([var["Name"] for var in self.GetPouInterfaceVars(pou)])
+for pou in project.getpous():
-for transition in pou.gettransitionList():
+if pou_name is None or pou_name == pou.getname():
-variables.append(transition.getname())
+variables.extend([var["Name"] for var in self.GetPouInterfaceVars(pou)])
-for action in pou.getactionList():
+for transition in pou.gettransitionList():
-variables.append(action.getname())
+variables.append(transition.getname())
+for action in pou.getactionList():
+variables.append(action.getname())
 return variables
-# Return if project is saved
-def ProjectIsSaved(self):
-return self.ProjectBuffer.IsCurrentSaved()
 # Return file path if project is an open file
 def GetFilePath(self):
 return self.FilePath
 def GetProgramFilePath(self):
 return self.ProgramFilePath
 # Return file name and point out if file is up to date
 def GetFilename(self):
-if self.ProjectBuffer.IsCurrentSaved():
+if self.Project is not None:
-return self.FileName
+if self.ProjectBuffer.IsCurrentSaved():
-else:
+return self.FileName
-return "~%s~"%self.FileName
+else:
+return "~%s~"%self.FileName
+return ""
 # Change file path and save file name or create a default one if file path not defined
 def SetFilePath(self, filepath):
 self.FilePath = filepath
 if filepath == "":
 else:
 self.FileName = os.path.splitext(os.path.basename(filepath))[0]
 # Change project properties
 def SetProjectProperties(self, name = None, properties = None):
-if name != None:
+if self.Project is not None:
-self.Project.setname(name)
+if name is not None:
-if properties != None:
+self.Project.setname(name)
-self.Project.setfileHeader(properties)
+if properties is not None:
-self.Project.setcontentHeader(properties)
+self.Project.setfileHeader(properties)
-if name != None or properties != None:
+self.Project.setcontentHeader(properties)
-self.BufferProject()
+if name is not None or properties is not None:
+self.BufferProject()
 # Return project properties
-def GetProjectProperties(self):
+def GetProjectProperties(self, debug = False):
-properties = self.Project.getfileHeader()
+project = self.GetProject(debug)
-properties.update(self.Project.getcontentHeader())
+if project is not None:
-return properties
+properties = project.getfileHeader()
+properties.update(project.getcontentHeader())
+return properties
+return None
 # Return project informations
-def GetProjectInfos(self):
+def GetProjectInfos(self, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-infos = {"name": self.Project.getname(), "type": ITEM_PROJECT}
+if project is not None:
+infos = {"name": project.getname(), "type": ITEM_PROJECT}
 datatypes = {"name": "Data Types", "type": ITEM_DATATYPES, "values":[]}
-for datatype in self.Project.getdataTypes():
+for datatype in project.getdataTypes():
 datatypes["values"].append({"name": datatype.getname(), "type": ITEM_DATATYPE,
 "tagname": self.ComputeDataTypeName(datatype.getname()), "values": []})
 pou_types = {"function": {"name": "Functions", "type": ITEM_FUNCTION, "values":[]},
 "functionBlock": {"name": "Function Blocks", "type": ITEM_FUNCTIONBLOCK, "values":[]},
 "program": {"name": "Programs", "type": ITEM_PROGRAM, "values":[]}}
-for pou in self.Project.getpous():
+for pou in project.getpous():
 pou_type = pou.getpouType()
 pou_infos = {"name": pou.getname(), "type": ITEM_POU,
 "tagname": self.ComputePouName(pou.getname())}
 pou_values = []
 if pou.getbodyType() == "SFC":
 pou_values.append({"name": "Actions", "type": ITEM_ACTIONS, "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_CONFIGURATIONS, "values": []}
-for config in self.Project.getconfigurations():
+for config in project.getconfigurations():
 config_name = config.getname()
 config_infos = {"name": config_name, "type": ITEM_CONFIGURATION,
 "tagname": self.ComputeConfigurationName(config.getname()),
 "values": []}
 resources = {"name": "Resources", "type": ITEM_RESOURCES, "values": []}
 pou_types["program"], configurations]
 return infos
 return None
 # Return project topology informations
-def GetProjectTopology(self):
+def GetProjectTopology(self, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-infos = {"name": self.Project.getname(), "type": ITEM_PROJECT, "values" : []}
+if project is not None:
-for config in self.Project.getconfigurations():
+infos = {"name": project.getname(), "type": ITEM_PROJECT, "values" : []}
+for config in project.getconfigurations():
 config_infos = {"name" : config.getname(), "type": ITEM_CONFIGURATION, "values" : []}
 for resource in config.getresource():
 resource_infos = {"name" : resource.getname(), "type": ITEM_RESOURCE, "values": []}
 for task in resource.gettask():
 for pou in task.getpouInstance():
-instance_infos = self.GetPouTopology(pou.getname(), pou.gettype())
+instance_infos = self.GetPouTopology(pou.getname(), pou.gettype(), debug=debug)
 if instance_infos is not None:
 resource_infos["values"].append(instance_infos)
 for pou in resource.getpouInstance():
-instance_infos = self.GetPouTopology(pou.getname(), pou.gettype())
+instance_infos = self.GetPouTopology(pou.getname(), pou.gettype(), debug=debug)
 if instance_infos is not None:
 resource_infos["values"].append(instance_infos)
 for varlist in resource.getglobalVars():
 for variable in varlist.getvariable():
 vartype_content = variable.gettype().getcontent()
 if vartype_content["name"] == "derived":
-var_infos = self.GetPouTopology(variable.getname(), vartype_content["value"].getname(), True)
+var_infos = self.GetPouTopology(variable.getname(), vartype_content["value"].getname(), True, debug)
 if var_infos is not None:
 resource_infos["values"].append(var_infos)
 elif vartype_content["name"] in ["string", "wstring"]:
 resource_infos["values"].append({"name" : variable.getname(),
 "elmt_type" : vartype_content["name"].upper(),
 config_infos["values"].append(resource_infos)
 for varlist in config.getglobalVars():
 for variable in varlist.getvariable():
 vartype_content = variable.gettype().getcontent()
 if vartype_content["name"] == "derived":
-var_infos = self.GetPouTopology(variable.getname(), vartype_content["value"].getname(), True)
+var_infos = self.GetPouTopology(variable.getname(), vartype_content["value"].getname(), True, debug)
 if var_infos is not None:
 config_infos["values"].append(var_infos)
 elif vartype_content["name"] in ["string", "wstring"]:
 config_infos["values"].append({"name" : variable.getname(),
 "elmt_type" : vartype_content["name"].upper(),
 infos["values"].append(config_infos)
 return infos
 return None
 # Return pou topology informations
-def GetPouTopology(self, name, type, global_var=False):
+def GetPouTopology(self, name, type, global_var = False, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-pou = self.Project.getpou(type)
+if project is not None:
+pou = project.getpou(type)
 if pou is not None:
 pou_type = pou.getpouType()
 if pou_type == "function":
 return None
 elif pou_type == "program":
-pou_infos = {"name" : name, "elmt_type" : type, "type" : ITEM_PROGRAM, "values" : []}
+pou_infos = {"name" : name, "elmt_type" : type, "type" : ITEM_PROGRAM,
+"tagname" : self.ComputePouName(pou.getname()), "values" : []}
 else:
-pou_infos = {"name" : name, "elmt_type" : type, "type" : ITEM_FUNCTIONBLOCK, "values" : []}
+pou_infos = {"name" : name, "elmt_type" : type, "type" : ITEM_FUNCTIONBLOCK,
+"tagname" : self.ComputePouName(pou.getname()), "values" : []}
+if pou.getbodyType() == "SFC":
+for transition in pou.gettransitionList():
+pou_infos["values"].append({"name" : transition.getname(),
+"elmt_type" : "TRANSITION", "type" : ITEM_TRANSITION,
+"tagname" : self.ComputePouActionName(pou.getname(), transition.getname()),
+"values" : []})
+for action in pou.getactionList():
+pou_infos["values"].append({"name": action.getname(),
+"elmt_type" : "ACTION", "type": ITEM_ACTION,
+"tagname" : self.ComputePouActionName(pou.getname(), action.getname()),
+"values" : []})
 if pou.interface:
 # Extract variables from every varLists
 for type, varlist in pou.getvars():
 infos = VAR_CLASS_INFOS.get(type, None)
 if infos is not None:
 else:
 pou_infos["values"].append({"name" : variable.getname(),
 "elmt_type" : vartype_content["name"],
 "type" : current_var_class, "values" : []})
 return pou_infos
-block_infos = self.GetBlockType(type)
+block_infos = self.GetBlockType(type, debug = debug)
 if block_infos is not None:
 if block_infos["type"] == "function":
 return None
 elif block_infos["type"] == "program":
 pou_infos = {"name" : name, "elmt_type" : type, "type" : ITEM_PROGRAM, "values" : []}
 pou_infos["values"].append({"name" : varname, "elmt_type" : vartype, "type" : ITEM_VAR_INPUT, "values" : []})
 for varname, vartype, varmodifier in block_infos["outputs"]:
 pou_infos["values"].append({"name" : varname, "elmt_type" : vartype, "type" : ITEM_VAR_INPUT, "values" : []})
 return pou_infos
-if type in self.GetDataTypes():
+if type in self.GetDataTypes(debug = debug):
 if global_var:
 return {"name" : name, "elmt_type" : type, "type" : ITEM_VAR_GLOBAL, "values" : []}
 else:
 return {"name" : name, "elmt_type" : type, "type" : ITEM_VAR_LOCAL, "values" : []}
 return None
 # Return if data type given by name is used by another data type or pou
-def DataTypeIsUsed(self, name):
+def DataTypeIsUsed(self, name, debug = False):
-return self.Project.ElementIsUsed(name) or self.Project.DataTypeIsDerived(name)
+project = self.GetProject(debug)
+if project is not None:
+return project.ElementIsUsed(name) or project.DataTypeIsDerived(name)
+return False
 # Return if pou given by name is used by another pou
-def PouIsUsed(self, name):
+def PouIsUsed(self, name, debug = False):
-return self.Project.ElementIsUsed(name)
+project = self.GetProject(debug)
+if project is not None:
+return project.ElementIsUsed(name)
+return False
 # Return if pou given by name is directly or undirectly used by the reference pou
-def PouIsUsedBy(self, name, reference):
+def PouIsUsedBy(self, name, reference, debug = False):
-return self.Project.ElementIsUsedBy(name, reference)
+project = self.GetProject(debug)
+if project is not None:
+return project.ElementIsUsedBy(name, reference)
+return False
 def GenerateProgram(self, filepath):
-if self.Project:
+if self.Project is not None:
 try:
 self.ProgramChunks = GenerateCurrentProgram(self, self.Project)
+self.CurrentCompiledProject = self.Copy(self.Project)
 program_text = "".join([item[0] for item in self.ProgramChunks])
 programfile = open(filepath, "w")
 programfile.write(program_text)
 programfile.close()
 self.ProgramFilePath = filepath
 #                        Project Pous management functions
 #-------------------------------------------------------------------------------
 # Add a Data Type to Project
 def ProjectAddDataType(self, datatype_name):
-# Add the pou to project
+if self.Project is not None:
-self.Project.appenddataType(datatype_name)
+# Add the datatype to project
-self.BufferProject()
+self.Project.appenddataType(datatype_name)
+self.BufferProject()
 # Remove a Data Type from project
 def ProjectRemoveDataType(self, datatype_name):
-self.Project.removedataType(datatype_name)
+if self.Project is not None:
-self.BufferProject()
+self.Project.removedataType(datatype_name)
+self.BufferProject()
 # Add a Pou to Project
 def ProjectAddPou(self, pou_name, pou_type, body_type):
-# Add the pou to project
+if self.Project is not None:
-self.Project.appendpou(pou_name, pou_type, body_type)
+# Add the pou to project
-if pou_type == "function":
+self.Project.appendpou(pou_name, pou_type, body_type)
-self.SetPouInterfaceReturnType(pou_name, "BOOL")
+if pou_type == "function":
-self.BufferProject()
+self.SetPouInterfaceReturnType(pou_name, "BOOL")
+self.BufferProject()
 # Remove a Pou from project
 def ProjectRemovePou(self, pou_name):
-self.Project.removepou(pou_name)
+if self.Project is not None:
-self.BufferProject()
+self.Project.removepou(pou_name)
+self.BufferProject()
 # Add a configuration to Project
 def ProjectAddConfiguration(self, config_name):
-self.Project.addconfiguration(config_name)
+if self.Project is not None:
-self.BufferProject()
+self.Project.addconfiguration(config_name)
+self.BufferProject()
 # Remove a configuration from project
 def ProjectRemoveConfiguration(self, config_name):
-self.Project.removeconfiguration(config_name)
+if self.Project is not None:
-self.BufferProject()
+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)
+if self.Project is not None:
-self.BufferProject()
+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)
+if self.Project is not None:
-self.BufferProject()
+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)
+if self.Project is not None:
-pou.addtransition(transition_name, transition_type)
+pou = self.Project.getpou(pou_name)
-self.BufferProject()
+if pou is not None:
+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)
+# Search if the pou removed is currently opened
-pou.removetransition(transition_name)
+if self.Project is not None:
-self.BufferProject()
+pou = self.Project.getpou(pou_name)
+if pou is not None:
+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)
+if self.Project is not None:
-pou.addaction(action_name, action_type)
+pou = self.Project.getpou(pou_name)
-self.BufferProject()
+if pou is not None:
+pou.addaction(action_name, action_type)
+self.BufferProject()
 # Remove an Action from a Project Pou
 def ProjectRemovePouAction(self, pou_name, action_name):
 # Search if the pou removed is currently opened
-for i, element in enumerate(self.ElementsOpened):
+if self.Project is not None:
-words = element.split("::")
+pou = self.Project.getpou(pou_name)
-if words[0] == "A" and words[1] == pou_name and words[2] == action_name:
+if pou is not None:
-self.RemoveElementEditing(i)
+pou.removeaction(action_name)
-pou = self.Project.getpou(pou_name)
+self.BufferProject()
-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
+if self.Project is not None:
-datatype = self.Project.getdataType(old_name)
+# Found the pou corresponding to old name and change its name to new name
-datatype.setname(new_name)
+datatype = self.Project.getdataType(old_name)
-self.Project.updateElementName(old_name, new_name)
+if datatype is not None:
-self.BufferProject()
+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
+if self.Project is not None:
-pou = self.Project.getpou(old_name)
+# Found the pou corresponding to old name and change its name to new name
-pou.setname(new_name)
+pou = self.Project.getpou(old_name)
-self.Project.updateElementName(old_name, new_name)
+if pou is not None:
-self.Project.RefreshElementUsingTree()
+pou.setname(new_name)
-self.Project.RefreshCustomBlockTypes()
+self.Project.updateElementName(old_name, new_name)
-self.BufferProject()
+self.Project.RefreshElementUsingTree()
+self.Project.RefreshCustomBlockTypes()
+self.BufferProject()
 # 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
+if self.Project is not None:
-pou = self.Project.getpou(pou_name)
+# Found the pou transition corresponding to old name and change its name to new name
-transition = pou.gettransition(old_name)
+pou = self.Project.getpou(pou_name)
-transition.setname(new_name)
+if pou is not None:
-pou.updateElementName(old_name, new_name)
+transition = pou.gettransition(old_name)
-self.BufferProject()
+if transition is not None:
+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
+if self.Project is not None:
-pou = self.Project.getpou(pou_name)
+# Found the pou action corresponding to old name and change its name to new name
-action = pou.getaction(old_name)
+pou = self.Project.getpou(pou_name)
-action.setname(new_name)
+if pou is not None:
-pou.updateElementName(old_name, new_name)
+action = pou.getaction(old_name)
-self.BufferProject()
+if action is not None:
+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
+if self.Project is not None:
-pou = self.Project.getpou(pou_name)
+# Found the pou action corresponding to old name and change its name to new name
-for type, varlist in pou.getvars():
+pou = self.Project.getpou(pou_name)
-for var in varlist.getvariable():
+if pou is not None:
-if var.getname() == old_name:
+for type, varlist in pou.getvars():
-var.setname(new_name)
+for var in varlist.getvariable():
-self.Project.RefreshCustomBlockTypes()
+if var.getname() == old_name:
-self.BufferProject()
+var.setname(new_name)
+self.Project.RefreshCustomBlockTypes()
+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
+if self.Project is not None:
-configuration = self.Project.getconfiguration(old_name)
+# Found the configuration corresponding to old name and change its name to new name
-configuration.setname(new_name)
+configuration = self.Project.getconfiguration(old_name)
-self.BufferProject()
+if configuration is not None:
+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
+if self.Project is not None:
-resource = self.Project.getconfigurationResource(config_name)
+# Found the resource corresponding to old name and change its name to new name
-resource.setName(new_name)
+resource = self.Project.getconfigurationResource(config_name)
-self.BufferProject()
+if resource is not None:
+resource.setName(new_name)
+self.BufferProject()
 # Return the type of the pou given by its name
-def GetPouType(self, name):
+def GetPouType(self, name, debug = False):
-# Found the pou correponding to name and return its type
+project = self.GetProject(debug)
-pou = self.Project.getpou(name)
+if project is not None:
-return pou.getpouType()
+# Found the pou correponding to name and return its type
+pou = project.getpou(name)
+if pou is not None:
+return pou.getpouType()
+return None
 # Return pous with SFC language
-def GetSFCPous(self):
+def GetSFCPous(self, debug = False):
 list = []
-if self.Project:
+project = self.GetProject(debug)
-for pou in self.Project.getpous():
+if project is not None:
+for pou in project.getpous():
 if pou.getBodyType() == "SFC":
 list.append(pou.getname())
 return list
 # Return the body language of the pou given by its name
-def GetPouBodyType(self, name):
+def GetPouBodyType(self, name, debug = False):
-# Found the pou correponding to name and return its body language
+project = self.GetProject(debug)
-pou = self.Project.getpou(name)
+if project is not None:
-return pou.getbodyType()
+# Found the pou correponding to name and return its body language
+pou = project.getpou(name)
+if pou is not None:
+return pou.getbodyType()
+return None
 # Return the actions of a pou
-def GetPouTransitions(self, pou_name):
+def GetPouTransitions(self, pou_name, debug = False):
 transitions = []
-pou = self.Project.getpou(pou_name)
+project = self.GetProject(debug)
-if pou.getbodyType() == "SFC":
+if project is not None:
-for transition in pou.gettransitionList():
+# Found the pou correponding to name and return its transitions if SFC
-transitions.append(transition.getname())
+pou = project.getpou(pou_name)
+if pou is not None and 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):
+def GetTransitionBodyType(self, pou_name, pou_transition, debug = False):
-# Found the pou correponding to name and return its body language
+project = self.GetProject(debug)
-pou = self.Project.getpou(pou_name)
+if project is not None:
-transition = pou.gettransition(pou_transition)
+# Found the pou correponding to name
-return transition.getbodyType()
+pou = project.getpou(pou_name)
+if pou is not None:
+# Found the pou transition correponding to name and return its body language
+transition = pou.gettransition(pou_transition)
+if transition is not None:
+return transition.getbodyType()
+return None
 # Return the actions of a pou
-def GetPouActions(self, pou_name):
+def GetPouActions(self, pou_name, debug = False):
 actions = []
-pou = self.Project.getpou(pou_name)
+project = self.GetProject(debug)
-if pou.getbodyType() == "SFC":
+if project is not None:
-for action in pou.getactionList():
+# Found the pou correponding to name and return its actions if SFC
-actions.append(action.getname())
+pou = 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):
+def GetActionBodyType(self, pou_name, pou_action, debug = False):
-# Found the pou correponding to name and return its body language
+project = self.GetProject(debug)
-pou = self.Project.getpou(pou_name)
+if project is not None:
-action = pou.getaction(pou_action)
+# Found the pou correponding to name and return its body language
-return action.getbodyType()
+pou = project.getpou(pou_name)
+if pou is not None:
+action = pou.getaction(pou_action)
+if action is not None:
+return action.getbodyType()
+return None
 # Extract varlists from a list of vars
 def ExtractVarLists(self, vars):
 varlist_list = []
 current_varlist = None
 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
+if self.Project is not None:
-configuration = self.Project.getconfiguration(name)
+# Found the configuration corresponding to name
-if configuration:
+configuration = self.Project.getconfiguration(name)
-# Set configuration global vars
+if configuration is not None:
-configuration.setglobalVars([])
+# Set configuration global vars
-for vartype, varlist in self.ExtractVarLists(vars):
+configuration.setglobalVars([])
-configuration.globalVars.append(varlist)
+for vartype, varlist in self.ExtractVarLists(vars):
+configuration.globalVars.append(varlist)
 # Return the configuration globalvars
-def GetConfigurationGlobalVars(self, name):
+def GetConfigurationGlobalVars(self, name, debug = False):
 vars = []
-# Found the configuration corresponding to name
+project = self.GetProject(debug)
-configuration = self.Project.getconfiguration(name)
+if project is not None:
-if configuration:
+# Found the configuration corresponding to name
-# Extract variables from every varLists
+configuration = project.getconfiguration(name)
-for varlist in configuration.getglobalVars():
+if configuration is not None:
-for var in varlist.getvariable():
+# Extract variables from every varLists
-tempvar = {"Name" : var.getname(), "Class" : "Global"}
+for varlist in configuration.getglobalVars():
-vartype_content = var.gettype().getcontent()
+for var in varlist.getvariable():
-if vartype_content["name"] == "derived":
+tempvar = {"Name" : var.getname(), "Class" : "Global"}
-tempvar["Type"] = vartype_content["value"].getname()
+vartype_content = var.gettype().getcontent()
-elif vartype_content["name"] in ["string", "wstring"]:
+if vartype_content["name"] == "derived":
-tempvar["Type"] = vartype_content["name"].upper()
+tempvar["Type"] = vartype_content["value"].getname()
-else:
+elif vartype_content["name"] in ["string", "wstring"]:
-tempvar["Type"] = vartype_content["name"]
+tempvar["Type"] = vartype_content["name"].upper()
-tempvar["Edit"] = True
+else:
-initial = var.getinitialValue()
+tempvar["Type"] = vartype_content["name"]
-if initial:
+tempvar["Edit"] = True
-tempvar["Initial Value"] = initial.getvalue()
+initial = var.getinitialValue()
-else:
+if initial:
-tempvar["Initial Value"] = ""
+tempvar["Initial Value"] = initial.getvalue()
-address = var.getaddress()
+else:
-if address:
+tempvar["Initial Value"] = ""
-tempvar["Location"] = address
+address = var.getaddress()
-else:
+if address:
-tempvar["Location"] = ""
+tempvar["Location"] = address
-if varlist.getretain():
+else:
-tempvar["Retain"] = "Yes"
+tempvar["Location"] = ""
-else:
+if varlist.getretain():
-tempvar["Retain"] = "No"
+tempvar["Retain"] = "Yes"
-if varlist.getconstant():
+else:
-tempvar["Constant"] = "Yes"
+tempvar["Retain"] = "No"
-else:
+if varlist.getconstant():
-tempvar["Constant"] = "No"
+tempvar["Constant"] = "Yes"
-vars.append(tempvar)
+else:
+tempvar["Constant"] = "No"
+vars.append(tempvar)
 return vars
 # Replace the resource globalvars by those given
 def SetConfigurationResourceGlobalVars(self, config_name, name, vars):
-# Found the resource corresponding to name
+if self.Project is not None:
-resource = self.Project.getconfigurationResource(config_name, name)
+# Found the resource corresponding to name
-# Set resource global vars
+resource = self.Project.getconfigurationResource(config_name, name)
-if resource:
+# Set resource global vars
-resource.setglobalVars([])
+if resource is not None:
-for vartype, varlist in self.ExtractVarLists(vars):
+resource.setglobalVars([])
-resource.globalVars.append(varlist)
+for vartype, varlist in self.ExtractVarLists(vars):
+resource.globalVars.append(varlist)
 # Return the resource globalvars
-def GetConfigurationResourceGlobalVars(self, config_name, name):
+def GetConfigurationResourceGlobalVars(self, config_name, name, debug = False):
 vars = []
-# Found the resource corresponding to name
+project = self.GetProject(debug)
-resource = self.Project.getconfigurationResource(config_name, name)
+if project is not None:
-if resource:
+# Found the resource corresponding to name
-# Extract variables from every varLists
+resource = project.getconfigurationResource(config_name, name)
-for varlist in resource.getglobalVars():
+if resource:
-for var in varlist.getvariable():
+# Extract variables from every varLists
-tempvar = {"Name" : var.getname(), "Class" : "Global"}
+for varlist in resource.getglobalVars():
-vartype_content = var.gettype().getcontent()
+for var in varlist.getvariable():
-if vartype_content["name"] == "derived":
+tempvar = {"Name" : var.getname(), "Class" : "Global"}
-tempvar["Type"] = vartype_content["value"].getname()
+vartype_content = var.gettype().getcontent()
-elif vartype_content["name"] in ["string", "wstring"]:
+if vartype_content["name"] == "derived":
-tempvar["Type"] = vartype_content["name"].upper()
+tempvar["Type"] = vartype_content["value"].getname()
-else:
+elif vartype_content["name"] in ["string", "wstring"]:
-tempvar["Type"] = vartype_content["name"]
+tempvar["Type"] = vartype_content["name"].upper()
-tempvar["Edit"] = True
+else:
-initial = var.getinitialValue()
+tempvar["Type"] = vartype_content["name"]
-if initial:
+tempvar["Edit"] = True
-tempvar["Initial Value"] = initial.getvalue()
+initial = var.getinitialValue()
-else:
+if initial:
-tempvar["Initial Value"] = ""
+tempvar["Initial Value"] = initial.getvalue()
-address = var.getaddress()
+else:
-if address:
+tempvar["Initial Value"] = ""
-tempvar["Location"] = address
+address = var.getaddress()
-else:
+if address:
-tempvar["Location"] = ""
+tempvar["Location"] = address
-if varlist.getretain():
+else:
-tempvar["Retain"] = "Yes"
+tempvar["Location"] = ""
-else:
+if varlist.getretain():
-tempvar["Retain"] = "No"
+tempvar["Retain"] = "Yes"
-if varlist.getconstant():
+else:
-tempvar["Constant"] = "Yes"
+tempvar["Retain"] = "No"
-else:
+if varlist.getconstant():
-tempvar["Constant"] = "No"
+tempvar["Constant"] = "Yes"
-vars.append(tempvar)
+else:
+tempvar["Constant"] = "No"
+vars.append(tempvar)
 return vars
 # Return the interface of the pou given by its name
-def GetPouInterfaceVarsByName(self, name):
+def GetPouInterfaceVarsByName(self, name, debug = False):
-# Found the pou correponding to name and return the interface
+project = self.GetProject(debug)
-return self.GetPouInterfaceVars(self.Project.getpou(name))
+if project is not None:
+# Found the pou correponding to name and return the interface vars
+pou = project.getpou(name)
+if pou is not None:
+return self.GetPouInterfaceVars(pou)
+return None
 # Return the interface for the given pou
 def GetPouInterfaceVars(self, pou):
 vars = []
 # Verify that the pou has an interface
-if pou.interface:
+if pou.interface is not None:
 # 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()
 vars.append(tempvar)
 return vars
 # 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
+if self.Project is not None:
-pou = self.Project.getpou(name)
+# Found the pou corresponding to name and add interface if there isn't one yet
-if not pou.interface:
+pou = self.Project.getpou(name)
-pou.interface = plcopen.pou_interface()
+if pou is not None:
-# Set Pou interface
+if pou.interface is None:
-pou.setvars(self.ExtractVarLists(vars))
+pou.interface = plcopen.pou_interface()
-self.Project.RefreshElementUsingTree()
+# Set Pou interface
-self.Project.RefreshCustomBlockTypes()
+pou.setvars(self.ExtractVarLists(vars))
+self.Project.RefreshElementUsingTree()
+self.Project.RefreshCustomBlockTypes()
 # Replace the return type of the pou given by its name (only for functions)
 def SetPouInterfaceReturnType(self, name, type):
-pou = self.Project.getpou(name)
+if self.Project is not None:
-if not pou.interface:
+pou = self.Project.getpou(name)
-pou.interface = plcopen.pou_interface()
+if pou is not None:
-# If there isn't any return type yet, add it
+if pou.interface is None:
-return_type = pou.interface.getreturnType()
+pou.interface = plcopen.pou_interface()
-if not return_type:
+# If there isn't any return type yet, add it
-return_type = plcopen.dataType()
+return_type = pou.interface.getreturnType()
-pou.interface.setreturnType(return_type)
+if not return_type:
-# Change return type
+return_type = plcopen.dataType()
-if type in self.GetBaseTypes():
+pou.interface.setreturnType(return_type)
-if type == "STRING":
+# Change return type
-return_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
+if type in self.GetBaseTypes():
-elif type == "WSTRING":
+if type == "STRING":
-return_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
+return_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})
-else:
+elif type == "WSTRING":
-return_type.setcontent({"name" : type, "value" : None})
+return_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})
 else:
-derived_type = plcopen.derivedTypes_derived()
+return_type.setcontent({"name" : type, "value" : None})
-derived_type.setname(type)
+else:
-return_type.setcontent({"name" : "derived", "value" : derived_type})
+derived_type = plcopen.derivedTypes_derived()
-self.Project.RefreshElementUsingTree()
+derived_type.setname(type)
-self.Project.RefreshCustomBlockTypes()
+return_type.setcontent({"name" : "derived", "value" : derived_type})
+self.Project.RefreshElementUsingTree()
+self.Project.RefreshCustomBlockTypes()
 def UpdateProjectUsedPous(self, old_name, new_name):
 if self.Project:
 self.Project.updateElementName(old_name, new_name)
 if pou:
 pou.updateElementName(old_name, new_name)
 # 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
+project = self.GetProject(debug)
-return self.GetPouInterfaceReturnType(self.Project.getpou(name))
+if project is not None:
+# Found the pou correponding to name and return the return type
+pou = project.getpou(name)
+if pou is not None:
+return self.GetPouInterfaceReturnType(pou)
+return False
 # Return the return type of the given pou
 def GetPouInterfaceReturnType(self, pou):
 # Verify that the pou has an interface
-if pou.interface:
+if pou.interface is not None:
 # Return the return type if there is one
 return_type = pou.interface.getreturnType()
 if return_type:
 returntype_content = return_type.getcontent()
 if returntype_content["name"] == "derived":
 def ClearPluginTypes(self):
 for i in xrange(len(self.PluginTypes)):
 self.PluginTypes.pop(0)
 # Function that returns the block definition associated to the block type given
-def GetBlockType(self, type, inputs = None):
+def GetBlockType(self, type, inputs = None, debug = False):
 for category in BlockTypes + self.PluginTypes:
 for blocktype in category["list"]:
 if inputs:
 block_inputs = tuple([var_type for name, var_type, modifier in blocktype["inputs"]])
 same_inputs = inputs == block_inputs
 else:
 same_inputs = True
 if blocktype["name"] == type and same_inputs:
 return blocktype
-if self.Project:
+project = self.GetProject(debug)
-return self.Project.GetCustomBlockType(type, inputs)
+if project is not None:
+return project.GetCustomBlockType(type, inputs)
 return None
 # Return Block types checking for recursion
-def GetBlockTypes(self, tagname = ""):
+def GetBlockTypes(self, tagname = "", debug = False):
 type = None
 if self.Project:
 name = ""
 words = tagname.split("::")
 if words[0] in ["P","T","A"]:
 name = words[1]
-type = self.GetPouType(name)
+type = self.GetPouType(name, debug)
 if type == "function":
 blocktypes = []
 for category in BlockTypes + self.PluginTypes:
 cat = {"name" : category["name"], "list" : []}
 for block in category["list"]:
 cat["list"].append(block)
 if len(cat["list"]) > 0:
 blocktypes.append(cat)
 else:
 blocktypes = [category for category in BlockTypes + self.PluginTypes]
-if self.Project:
+project = self.GetProject(debug)
-blocktypes.append({"name" : "User-defined POUs", "list": self.Project.GetCustomBlockTypes(name)})
+if project is not None:
+blocktypes.append({"name" : "User-defined POUs", "list": project.GetCustomBlockTypes(name)})
 return blocktypes
 # Return Function Block types checking for recursion
-def GetFunctionBlockTypes(self, tagname = ""):
+def GetFunctionBlockTypes(self, tagname = "", debug = False):
 blocktypes = []
 for category in BlockTypes + self.PluginTypes:
 for block in category["list"]:
 if block["type"] != "function":
 blocktypes.append(block["name"])
-if self.Project:
+project = self.GetProject(debug)
+if project is not None:
 name = ""
 words = tagname.split("::")
 if words[0] in ["P","T","A"]:
 name = words[1]
-blocktypes.extend(self.Project.GetCustomFunctionBlockTypes(name))
+blocktypes.extend(project.GetCustomFunctionBlockTypes(name))
 return blocktypes
 # Return Block types checking for recursion
-def GetBlockResource(self):
+def GetBlockResource(self, debug = False):
 blocktypes = []
 for category in BlockTypes[:-1]:
 for blocktype in category["list"]:
 if blocktype["type"] == "program":
 blocktypes.append(blocktype["name"])
-if self.Project:
+project = self.GetProject(debug)
-blocktypes.extend(self.Project.GetCustomBlockResource())
+if project is not None:
+blocktypes.extend(project.GetCustomBlockResource())
 return blocktypes
 # Return Data Types checking for recursion
-def GetDataTypes(self, tagname = "", basetypes = True):
+def GetDataTypes(self, tagname = "", basetypes = True, debug = False):
 if basetypes:
 datatypes = self.GetBaseTypes()
 else:
 datatypes = []
-if self.Project:
+project = self.GetProject(debug)
+if project is not None:
 name = ""
 words = tagname.split("::")
 if words[0] in ["D"]:
 name = words[1]
-datatypes.extend(self.Project.GetCustomDataTypes(name))
+datatypes.extend(project.GetCustomDataTypes(name))
 return datatypes
 # Return Base Type of given possible derived type
-def GetBaseType(self, type):
+def GetBaseType(self, type, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-return self.Project.GetBaseType(type)
+if project is not None:
+return project.GetBaseType(type)
 return None
 # Return Base Types
 def GetBaseTypes(self):
 return [value for value in TypeHierarchy.keys() if not value.startswith("ANY")]
-def IsOfType(self, type, reference):
+def IsOfType(self, type, reference, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-return self.Project.IsOfType(type, reference)
+if project is not None:
+return project.IsOfType(type, reference)
 elif reference is None:
 return True
 elif type == reference:
 return True
 else:
 def IsEndType(self, type):
 if type is not None:
 return not type.startswith("ANY")
 return True
-def GetDataTypeRange(self, type):
+def GetDataTypeRange(self, type, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-return self.Project.GetDataTypeRange(type)
+if project is not None:
+return project.GetDataTypeRange(type)
 elif type in DataTypeRange:
 return DataTypeRange[type]
 return None
 # Return Subrange types
-def GetSubrangeBaseTypes(self, exclude):
+def GetSubrangeBaseTypes(self, exclude, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-return self.Project.GetSubrangeBaseTypes(exclude)
+if project is not None:
+return project.GetSubrangeBaseTypes(exclude)
 return []
 # Return Enumerated Values
-def GetEnumeratedDataValues(self):
+def GetEnumeratedDataValues(self, debug = False):
-if self.Project:
+project = self.GetProject(debug)
-return self.Project.GetEnumeratedDataTypeValues()
+if project is not None:
+return project.GetEnumeratedDataTypeValues()
 return []
 #-------------------------------------------------------------------------------
 #                   Project Element tag name computation functions
 #-------------------------------------------------------------------------------
 #-------------------------------------------------------------------------------
 #                    Project opened Data types management functions
 #-------------------------------------------------------------------------------
 # Return the data type informations
-def GetDataTypeInfos(self, tagname):
+def GetDataTypeInfos(self, tagname, debug = False):
-words = tagname.split("::")
+project = self.GetProject(debug)
-if words[0] == "D":
+if project is not None:
-infos = {}
+words = tagname.split("::")
-datatype = self.Project.getdataType(words[1])
+if words[0] == "D":
-basetype_content = datatype.baseType.getcontent()
+infos = {}
-if basetype_content["value"] is None:
+datatype = project.getdataType(words[1])
-infos["type"] = "Directly"
+basetype_content = datatype.baseType.getcontent()
-infos["base_type"] = basetype_content["name"]
+if basetype_content["value"] is None:
-elif basetype_content["name"] == "derived":
+infos["type"] = "Directly"
-infos["type"] = "Directly"
+infos["base_type"] = basetype_content["name"]
-infos["base_type"] = basetype_content["value"].getname()
+elif basetype_content["name"] == "derived":
-elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:
+infos["type"] = "Directly"
-infos["type"] = "Subrange"
+infos["base_type"] = basetype_content["value"].getname()
-infos["min"] = basetype_content["value"].range.getlower()
+elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:
-infos["max"] = basetype_content["value"].range.getupper()
+infos["type"] = "Subrange"
-base_type = basetype_content["value"].baseType.getcontent()
+infos["min"] = basetype_content["value"].range.getlower()
-if base_type["value"] is None:
+infos["max"] = basetype_content["value"].range.getupper()
-infos["base_type"] = base_type["name"]
+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()
+elif basetype_content["name"] == "enum":
+infos["type"] = "Enumerated"
+infos["values"] = []
+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((dimension.getlower(), 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()
+if datatype.initialValue is not None:
+infos["initial"] = str(datatype.initialValue.getvalue())
 else:
-infos["base_type"] = base_type["value"].getname()
+infos["initial"] = ""
-elif basetype_content["name"] == "enum":
+return infos
-infos["type"] = "Enumerated"
-infos["values"] = []
-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((dimension.getlower(), 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()
-if datatype.initialValue is not None:
-infos["initial"] = str(datatype.initialValue.getvalue())
-else:
-infos["initial"] = ""
-return infos
 return None
 # Change the data type informations
 def SetDataTypeInfos(self, tagname, infos):
 words = tagname.split("::")
-if words[0] == "D":
+if self.Project is not None and words[0] == "D":
 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({"name" : "string", "value" : plcopen.elementaryTypes_string()})
 #-------------------------------------------------------------------------------
 #                       Project opened Pous management functions
 #-------------------------------------------------------------------------------
 # Return edited element
-def GetEditedElement(self, tagname):
+def GetEditedElement(self, tagname, debug = False):
-words = tagname.split("::")
+project = self.GetProject(debug)
-if words[0] == "D":
+if project is not None:
-return self.Project.getdataType(words[1])
+words = tagname.split("::")
-elif words[0] == "P":
+if words[0] == "D":
-return self.Project.getpou(words[1])
+return project.getdataType(words[1])
-elif words[0] in ['T', 'A']:
+elif words[0] == "P":
-pou = self.Project.getpou(words[1])
+return project.getpou(words[1])
-if words[0] == 'T':
+elif words[0] in ['T', 'A']:
-return pou.gettransition(words[2])
+pou = project.getpou(words[1])
-elif words[0] == 'A':
+if pou is not None:
-return pou.getaction(words[2])
+if words[0] == 'T':
-elif words[0] == 'C':
+return pou.gettransition(words[2])
-return self.Project.getconfiguration(words[1])
+elif words[0] == 'A':
-elif words[0] == 'R':
+return pou.getaction(words[2])
-return self.Project.getconfigurationResource(words[1], words[2])
+elif words[0] == 'C':
+return project.getconfiguration(words[1])
+elif words[0] == 'R':
+return project.getconfigurationResource(words[1], words[2])
 return None
 # Return edited element name
 def GetEditedElementName(self, tagname):
 words = tagname.split("::")
 else:
 return words[2]
 return None
 # Return edited element name and type
-def GetEditedElementType(self, tagname):
+def GetEditedElementType(self, tagname, debug = False):
 words = tagname.split("::")
 if words[0] in ["P","T","A"]:
-return words[1], self.GetPouType(words[1])
+return words[1], self.GetPouType(words[1], debug)
 return None, None
 # Return language in which edited element is written
-def GetEditedElementBodyType(self, tagname):
+def GetEditedElementBodyType(self, tagname, debug = False):
 words = tagname.split("::")
 if words[0] == "P":
-return self.GetPouBodyType(words[1])
+return self.GetPouBodyType(words[1], debug)
 elif words[0] == 'T':
-return self.GetTransitionBodyType(words[1], words[2])
+return self.GetTransitionBodyType(words[1], words[2], debug)
 elif words[0] == 'A':
-return self.GetActionBodyType(words[1], words[2])
+return self.GetActionBodyType(words[1], words[2], debug)
 return None
 # Return the edited element variables
-def GetEditedElementInterfaceVars(self, tagname):
+def GetEditedElementInterfaceVars(self, tagname, debug = False):
 words = tagname.split("::")
 if words[0] in ["P","T","A"]:
-pou = self.Project.getpou(words[1])
+project = self.GetProject(debug)
-return self.GetPouInterfaceVars(pou)
+if project is not None:
+pou = project.getpou(words[1])
+if pou is not None:
+return self.GetPouInterfaceVars(pou)
 return []
 # Return the edited element return type
-def GetEditedElementInterfaceReturnType(self, tagname):
+def GetEditedElementInterfaceReturnType(self, tagname, debug = False):
 words = tagname.split("::")
 if words[0] == "P":
-pou = self.Project.getpou(words[1])
+project = self.GetProject(debug)
-return self.GetPouInterfaceReturnType(pou)
+if project is not None:
+pou = self.Project.getpou(words[1])
+if pou is not None:
+return self.GetPouInterfaceReturnType(pou)
 elif words[0] == 'T':
 return "BOOL"
 return None
 # Change the edited element text
 def SetEditedElementText(self, tagname, text):
-element = self.GetEditedElement(tagname)
+if self.Project is not None:
-if element != None:
+element = self.GetEditedElement(tagname)
-element.settext(text)
+if element is not None:
-self.Project.RefreshElementUsingTree()
+element.settext(text)
+self.Project.RefreshElementUsingTree()
 # Return the edited element text
-def GetEditedElementText(self, tagname):
+def GetEditedElementText(self, tagname, debug = False):
-element = self.GetEditedElement(tagname)
+element = self.GetEditedElement(tagname, debug)
-if element != None:
+if element is not None:
 return element.gettext()
 return ""
 # Return the edited element transitions
-def GetEditedElementTransitions(self, tagname):
+def GetEditedElementTransitions(self, tagname, debug = False):
-pou = self.GetEditedElement(tagname)
+pou = self.GetEditedElement(tagname, debug)
-if pou != None and pou.getbodyType() == "SFC":
+if pou is not None and pou.getbodyType() == "SFC":
 transitions = []
 for transition in pou.gettransitionList():
 transitions.append(transition.getname())
 return transitions
 return []
 # Return edited element transitions
-def GetEditedElementActions(self, tagname):
+def GetEditedElementActions(self, tagname, debug = False):
-pou = self.GetEditedElement(tagname)
+pou = self.GetEditedElement(tagname, debug)
-if pou != None and pou.getbodyType() == "SFC":
+if pou is None and pou.getbodyType() == "SFC":
 actions = []
 for action in pou.getactionList():
 actions.append(action.getname())
 return actions
 return []
 # Return the names of the pou elements
-def GetEditedElementVariables(self, tagname):
+def GetEditedElementVariables(self, tagname, debug = False):
 words = tagname.split("::")
 if words[0] in ["P","T","A"]:
-return self.GetProjectPouVariables(words[1])
+return self.GetProjectPouVariables(words[1], debug)
 return []
 # Return the current pou editing informations
-def GetEditedElementInstanceInfos(self, tagname, id = None, exclude = []):
+def GetEditedElementInstanceInfos(self, tagname, id = None, exclude = [], debug = False):
 infos = {}
 instance = None
-element = self.GetEditedElement(tagname)
+element = self.GetEditedElement(tagname, debug)
 if element is not None:
 # if id is defined
 if id is not None:
 instance = element.getinstance(id)
 else:
 connector["negated"] = variable.getnegated()
 connector["edge"] = variable.getedge()
 infos["connectors"]["outputs"].append(connector)
 elif isinstance(instance, plcopen.fbdObjects_inVariable):
 infos["name"] = instance.getexpression()
-infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"])
+infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"], debug)
 infos["type"] = "input"
 executionOrder = instance.getexecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 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["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"], debug)
 infos["type"] = "output"
 executionOrder = instance.getexecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 for link in connections:
 dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connector"]["links"].append(dic)
 elif isinstance(instance, plcopen.fbdObjects_inOutVariable):
 infos["name"] = instance.getexpression()
-infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"])
+infos["value_type"] = self.GetEditedElementVarValueType(tagname, infos["name"], debug)
 infos["type"] = "inout"
 executionOrder = instance.getexecutionOrderId()
 if executionOrder is not None:
 infos["executionOrder"] = executionOrder
 else:
 if connections:
 for link in connections:
 dic = {"refLocalId":link.getrefLocalId(),"points":link.getpoints(),"formalParameter":link.getformalParameter()}
 infos["connector"]["links"].append(dic)
 return infos
-return False
+return None
 def ClearEditedElementExecutionOrder(self, tagname):
 element = self.GetEditedElement(tagname)
 if element is not None:
 element.resetexecutionOrder()
 element = self.GetEditedElement(tagname)
 if element is not None:
 element.compileexecutionOrder()
 # Return the variable type of the given pou
-def GetEditedElementVarValueType(self, tagname, varname):
+def GetEditedElementVarValueType(self, tagname, varname, debug = False):
-words = tagname.split("::")
+project = self.GetProject(debug)
-if words[0] in ["P","T","A"]:
+if project is not None:
-pou = self.Project.getpou(words[1])
+words = tagname.split("::")
-for type, varlist in pou.getvars():
+if words[0] in ["P","T","A"]:
-for var in varlist.getvariable():
+pou = self.Project.getpou(words[1])
-if var.getname() == varname:
+if pou is not None:
-vartype_content = var.gettype().getcontent()
+for type, varlist in pou.getvars():
-if vartype_content["name"] == "derived":
+for var in varlist.getvariable():
-return vartype_content["value"].getname()
+if var.getname() == varname:
-elif vartype_content["name"] in ["string", "wstring"]:
+vartype_content = var.gettype().getcontent()
-return vartype_content["name"].upper()
+if vartype_content["name"] == "derived":
-else:
+return vartype_content["value"].getname()
-return vartype_content["name"]
+elif vartype_content["name"] in ["string", "wstring"]:
+return vartype_content["name"].upper()
+else:
+return vartype_content["name"]
 return None
 def SetConnectionWires(self, connection, connector):
 wires = connector.GetWires()
 idx = 0
 else:
 connection.setconnectionParameter(idx, None)
 idx += 1
 def AddEditedElementPouVar(self, tagname, type, name):
-words = tagname.split("::")
+if self.Project is not None:
-if words[0] in ['P', 'T', 'A']:
+words = tagname.split("::")
-pou = self.Project.getpou(words[1])
+if words[0] in ['P', 'T', 'A']:
-if not pou.interface:
+pou = self.Project.getpou(words[1])
-pou.interface = plcopen.pou_interface()
+if pou is not None:
-pou.addpouVar(type, name)
+if pou.interface is None:
+pou.interface = plcopen.pou_interface()
+pou.addpouVar(type, name)
 def ChangeEditedElementPouVar(self, tagname, old_type, old_name, new_type, new_name):
-words = tagname.split("::")
+if self.Project is not None:
-if words[0] in ['P', 'T', 'A']:
+words = tagname.split("::")
-pou = self.Project.getpou(words[1])
+if words[0] in ['P', 'T', 'A']:
-pou.changepouVar(old_type, old_name, new_type, new_name)
+pou = self.Project.getpou(words[1])
+if pou is not None:
+pou.changepouVar(old_type, old_name, new_type, new_name)
 def RemoveEditedElementPouVar(self, tagname, type, name):
-words = tagname.split("::")
+if self.Project is not None:
-if words[0] in ['P', 'T', 'A']:
+words = tagname.split("::")
-pou = self.Project.getpou(words[1])
+if words[0] in ['P', 'T', 'A']:
-pou.removepouVar(type, name)
+pou = self.Project.getpou(words[1])
+if pou is not None:
+pou.removepouVar(type, name)
 def AddEditedElementBlock(self, tagname, id, blocktype, blockname = None):
 element = self.GetEditedElement(tagname)
 if element is not None:
 block = plcopen.fbdObjects_block()
 if isinstance(instance, plcopen.fbdObjects_block):
 self.RemoveEditedElementPouVar(tagname, instance.gettypeName(), instance.getinstanceName())
 element.removeinstance(id)
 self.Project.RefreshElementUsingTree()
-def GetEditedResourceVariables(self, tagname):
+def GetEditedResourceVariables(self, tagname, debug = False):
 varlist = []
 words = tagname.split("::")
-for var in self.GetConfigurationGlobalVars(words[1]):
+for var in self.GetConfigurationGlobalVars(words[1], debug):
 if var["Type"] == "BOOL":
 varlist.append(var["Name"])
-for var in self.GetConfigurationResourceGlobalVars(words[1], words[2]):
+for var in self.GetConfigurationResourceGlobalVars(words[1], words[2], debug):
 if var["Type"] == "BOOL":
 varlist.append(var["Name"])
 return varlist
 def SetEditedResourceInfos(self, tagname, tasks, instances):
 if instance["Task"] != "":
 task_list[instance["Task"]].appendpouInstance(new_instance)
 else:
 resource.appendpouInstance(new_instance)
-def GetEditedResourceInfos(self, tagname):
+def GetEditedResourceInfos(self, tagname, debug = False):
-resource = self.GetEditedElement(tagname)
+resource = self.GetEditedElement(tagname, debug)
 if resource is not None:
 tasks = resource.gettask()
 instances = resource.getpouInstance()
 tasks_data = []
 instances_data = []
 self.SetFilePath(filepath)
 self.Project.RefreshElementUsingTree()
 self.Project.RefreshDataTypeHierarchy()
 self.Project.RefreshCustomBlockTypes()
 self.ProjectBuffer = UndoBuffer(self.Copy(self.Project), True)
+self.ProgramChunks = []
+self.CurrentCompiledProject = None
 self.Buffering = False
-self.ElementsOpened = []
 self.CurrentElementEditing = None
 return None
 return "No PLC project found"
 def SaveXMLFile(self, filepath = None):
 def EndBuffering(self):
 if self.Buffering:
 self.Project = self.Copy(self.Project)
 self.Buffering = False
+# Return if project is saved
 def ProjectIsSaved(self):
-if self.ProjectBuffer:
+if self.ProjectBuffer is not None:
 return self.ProjectBuffer.IsCurrentSaved()
 else:
 return True
 def LoadPrevious(self):

changeset 249	d8425712acef
parent 236	9f594b90bb1a
child 252	166ee9d2e233