--- 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 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\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: