plcopeneditor_history: comparison PLCGenerator.py

equal deleted inserted replaced

-:b622defdfd98
+:e9d01d824086
 from types import *
 varTypeNames = {"localVars" : "VAR", "tempVars" : "VAR_TEMP", "inputVars" : "VAR_INPUT",
 "outputVars" : "VAR_OUTPUT", "inOutVars" : "VAR_IN_OUT", "externalVars" : "VAR_EXTERNAL",
 "globalVars" : "VAR_GLOBAL", "accessVars" : "VAR_ACCESS"}
+def ReIndentText(text, nb_spaces):
+compute = ""
+lines = text.splitlines()
+if len(lines) > 0:
+spaces = 0
+while lines[0][spaces] == " ":
+spaces += 1
+indent = ""
+for i in xrange(spaces, nb_spaces):
+indent += " "
+for line in lines:
+compute += "%s%s\n"%(indent, line)
+return compute
 """
 Module implementing methods for generating PLC programs in ST or IL
 """
 class PouProgram:
 def __init__(self, name, type):
 self.Name = name
 self.Type = type
-self.Interface = {}
+self.ReturnType = None
-self.Steps = {}
+self.Interface = []
-self.Transitions = {}
+self.InitialSteps = []
-self.Order = []
+self.SFCNetworks = {"Steps":{}, "Transitions":{}, "Actions":{}}
 self.Program = ""
+def IsAlreadyDefined(self, name):
+for list_type, retain, constant, vars in self.Interface:
+for var_type, var_name in vars:
+if name == var_name:
+return True
+return False
 def GenerateInterface(self, interface):
 if self.Type == "FUNCTION":
-self.Interface["returnType"] = interface.getReturnType().getValue()
+self.ReturnType = interface.getReturnType().getValue()
 for varlist in interface.getContent():
-variables = {}
+variables = []
 for var in varlist["value"].getVariable():
 type = var.getType().getValue()
-if type not in variables:
+variables.append((type, var.getName()))
-variables[type] = []
+self.Interface.append((varTypeNames[varlist["name"]], varlist["value"].getRetain(),
-variables[type].append(var.getName())
+varlist["value"].getConstant(), variables))
-self.Interface[(varTypeNames[varlist["name"]], varlist["value"].getRetain(),
-varlist["value"].getConstant())] = variables
 def GenerateProgram(self, pou):
 body = pou.getBody()
 body_content = body.getContent()
 body_type = body_content["name"]
 if body_type in ["IL","ST"]:
-self.Program = "%s\n"%body_content["value"].getText()
+self.Program = ReIndentText(body_content["value"].getText(), 2)
 elif body_type == "FBD":
 for instance in body.getContentInstances():
 if isinstance(instance, plcopen.outVariable):
 var = instance.getExpression()
 connections = instance.connectionPointIn.getConnections()
 expression = self.ComputeLDExpression(paths, True)
 self.Program += "  %s := %s;\n"%(variable, expression)
 elif body_type == "SFC":
 for instance in body.getContentInstances():
 if isinstance(instance, plcopen.step):
-self.GenerateSFCSteps(instance, pou)
+self.GenerateSFCStep(instance, pou)
 elif isinstance(instance, plcopen.actionBlock):
-self.GenerateSFCActions(instance, pou)
+self.GenerateSFCStepActions(instance, pou)
 elif isinstance(instance, plcopen.transition):
-self.GenerateSFCTransitions(instance, pou)
+self.GenerateSFCTransition(instance, pou)
 elif isinstance(instance, plcopen.jumpStep):
 self.GenerateSFCJump(instance, pou)
-for name, values in self.Steps.items():
+for initialstep in self.InitialSteps:
-if values['initial']:
+self.ComputeSFCStep(initialstep)
-self.GenerateSFCStepOrder(name, [])
-steps_type = "ARRAY [1..%d] OF BOOL"%len(self.Order)
-if ("VAR", False, False) not in self.Interface:
-self.Interface[("VAR", False, False)] = {}
-if steps_type not in self.Interface[("VAR", False, False)]:
-self.Interface[("VAR", False, False)][steps_type] = ["Steps"]
-else:
-self.Interface[("VAR", False, False)][steps_type].append("Steps")
-for index, name in enumerate(self.Order):
-values = self.Steps[name]
-self.Program += "  IF Steps[%d] THEN\n"%index
-for action in values["actions"]:
-if action["qualifier"] == "N":
-for line in action["content"].splitlines():
-self.Program += "  %s\n"%line
-elif action["qualifier"] == "S":
-if "R_TRIG" not in self.Interface[("VAR", False, False)]:
-self.Interface[("VAR", False, False)]["R_TRIG"] = []
-i = 1
-name = "R_TRIG%d"%i
-while name in self.Interface[("VAR", False, False)]["R_TRIG"]:
-i += 1
-name = "R_TRIG%d"%i
-self.Interface[("VAR", False, False)]["R_TRIG"].append(name)
-self.Program += "    IF %s(CLK := Steps[%d]) THEN\n"%(name, index)
-self.Program += "      %s := TRUE;\n"%action["content"]
-for transition in values["transitions"]:
-if transition["compute"] != '':
-self.Program += "    %s %s"%(transition["condition"], transition["compute"])
-self.Program += "    IF %s THEN\n"%transition["condition"]
-for target in transition["targets"]:
-self.Program += "      Steps[%d] := TRUE;\n"%self.Order.index(target)
-self.Program += "      Steps[%d] := FALSE;\n"%index
 def ComputeFBDExpression(self, body, link):
 localid = link.getRefLocalId()
 instance = body.getContentInstance(localid)
 if isinstance(instance, plcopen.inVariable):
 value = self.ComputeFBDExpression(body, connections[0])
 vars.append(self.ExtractModifier(variable, value))
 variable = instance.outputVariables.getVariable()[0]
 return self.ExtractModifier(variable, "%s(%s)"%(type, ", ".join(vars)))
 elif block_infos["type"] == "functionBlock":
-if ("VAR", False, False) not in self.Interface:
+if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] or self.Interface[-1][2]:
-self.Interface[("VAR", False, False)] = {}
+self.Interface.append(("VAR", False, False, []))
-if type not in self.Interface[("VAR", False, False)]:
+if not self.IsAlreadyDefined(name):
-self.Interface[("VAR", False, False)][type] = []
+self.Interface[-1][3].append((type, name))
-if name not in self.Interface[("VAR", False, False)][type]:
-self.Interface[("VAR", False, False)][type].append(name)
 vars = []
 for variable in instance.inputVariables.getVariable():
 connections = variable.connectionPointIn.getConnections()
 if connections and len(connections) == 1:
 parameter = variable.getFormalParameter()
 elif paths[0]:
 return [variable, paths[0]]
 else:
 return variable
-def GenerateSFCSteps(self, step, pou):
+def GenerateSFCStep(self, step, pou):
 step_name = step.getName()
-if step_name not in self.Steps:
+if step_name not in self.SFCNetworks["Steps"].keys():
+if step.getInitialStep():
+self.InitialSteps.append(step_name)
 step_infos = {"initial" : step.getInitialStep(), "transitions" : [], "actions" : []}
-self.Steps[step_name] = step_infos
 if step.connectionPointIn:
 instances = []
 connections = step.connectionPointIn.getConnections()
 if len(connections) == 1:
 instanceLocalId = connections[0].getRefLocalId()
 instance = pou.body.getContentInstance(instanceLocalId)
 if isinstance(instance, plcopen.transition):
-self.GenerateSFCTransitions(instance, pou)
+self.GenerateSFCTransition(instance, pou)
 instances.append(instance)
 elif isinstance(instance, plcopen.selectionConvergence):
 for connectionPointIn in instance.getConnectionPointIn():
 divergence_connections = connectionPointIn.getConnections()
 if len(divergence_connections) == 1:
 transitionLocalId = connections[0].getRefLocalId()
 transition = pou.body.getContentInstance(transitionLocalId)
-self.GenerateSFCTransitions(transition, pou)
+self.GenerateSFCTransition(transition, pou)
+instances.append(transition)
+elif isinstance(instance, plcopen.simultaneousDivergence):
+connectionPointIn = instance.getConnectionPointIn()
+if connectionPointIn:
+divergence_connections = connectionPointIn.getConnections()
+if len(divergence_connections) == 1:
+transitionLocalId = connections[0].getRefLocalId()
+transition = pou.body.getContentInstance(transitionLocalId)
+self.GenerateSFCTransition(transition, pou)
 instances.append(transition)
 for instance in instances:
-self.Transitions[instance]["targets"].append(step_name)
+if instance in self.SFCNetworks["Transitions"].keys():
+self.SFCNetworks["Transitions"][instance]["to"].append(step_name)
+self.SFCNetworks["Steps"][step_name] = step_infos
 def GenerateSFCJump(self, jump, pou):
 jump_target = jump.getTargetName()
 if jump.connectionPointIn:
 instances = []
 connections = jump.connectionPointIn.getConnections()
 if len(connections) == 1:
 instanceLocalId = connections[0].getRefLocalId()
 instance = pou.body.getContentInstance(instanceLocalId)
 if isinstance(instance, plcopen.transition):
-self.GenerateSFCTransitions(instance, pou)
+self.GenerateSFCTransition(instance, pou)
 instances.append(instance)
 elif isinstance(instance, plcopen.selectionConvergence):
 for connectionPointIn in instance.getConnectionPointIn():
 divergence_connections = connectionPointIn.getConnections()
 if len(divergence_connections) == 1:
 transitionLocalId = divergence_connections[0].getRefLocalId()
 transition = pou.body.getContentInstance(transitionLocalId)
-self.GenerateSFCTransitions(transition, pou)
+self.GenerateSFCTransition(transition, pou)
+instances.append(transition)
+elif isinstance(instance, plcopen.simultaneousDivergence):
+connectionPointIn = instance.getConnectionPointIn()
+if connectionPointIn:
+divergence_connections = connectionPointIn.getConnections()
+if len(divergence_connections) == 1:
+transitionLocalId = connections[0].getRefLocalId()
+transition = pou.body.getContentInstance(transitionLocalId)
+self.GenerateSFCTransition(transition, pou)
 instances.append(transition)
 for instance in instances:
-self.Transitions[instance]["targets"].append(jump_target)
+if instance in self.SFCNetworks["Transitions"].keys():
+self.SFCNetworks["Transitions"][instance]["to"].append(jump_target)
-def GenerateSFCActions(self, actionBlock, pou):
+def GenerateSFCStepActions(self, actionBlock, pou):
 connections = actionBlock.connectionPointIn.getConnections()
 if len(connections) == 1:
 stepLocalId = connections[0].getRefLocalId()
 step = pou.body.getContentInstance(stepLocalId)
+self.GenerateSFCStep(step, pou)
 step_name = step.getName()
-if step_name not in self.Steps:
+if step_name in self.SFCNetworks["Steps"].keys():
-self.GenerateSFCSteps(step, pou)
-if step_name in self.Steps:
 actions = actionBlock.getActions()
 for action in actions:
-action_infos = {"qualifier" : action["qualifier"], "content" : ""}
+action_infos = {"qualifier" : action["qualifier"], "content" : action["value"]}
-if action["type"] == "inline":
+if "duration" in action:
-action_infos["content"] = action["value"]
+action_infos["duration"] = action["duration"]
-elif action["type"] == "reference":
+if "indicator" in action:
-actionContent = pou.getAction(action["value"])
+action_infos["indicator"] = action["indicator"]
-if actionContent:
+if action["type"] == "reference":
-actionType = actionContent.getBodyType()
+self.GenerateSFCAction(action["value"], pou)
-actionBody = actionContent.getBody()
+self.SFCNetworks["Steps"][step_name]["actions"].append(action_infos)
-if actionType in ["ST", "IL"]:
-action_infos["content"] = actionContent.getText()
+def GenerateSFCAction(self, action_name, pou):
-elif actionType == "FBD":
+if action_name not in self.SFCNetworks["Actions"].keys():
-for instance in actionBody.getContentInstances():
+actionContent = pou.getAction(action_name)
-if isinstance(instance, plcopen.outVariable):
+if actionContent:
-var = instance.getExpression()
+actionType = actionContent.getBodyType()
-connections = instance.connectionPointIn.getConnections()
+actionBody = actionContent.getBody()
-if connections and len(connections) == 1:
+if actionType in ["ST", "IL"]:
-expression = self.ComputeFBDExpression(actionBody, connections[0])
+self.SFCNetworks["Actions"][action_name] = ReIndentText(actionContent.getText(), 4)
-action_infos["content"] = self.Program + "  %s := %s;"%(var, expression)
+elif actionType == "FBD":
-self.Program = ""
+for instance in actionBody.getContentInstances():
-elif actionType == "LD":
+if isinstance(instance, plcopen.outVariable):
-for instance in actionbody.getContentInstances():
+var = instance.getExpression()
-if isinstance(instance, plcopen.coil):
+connections = instance.connectionPointIn.getConnections()
-paths = self.GenerateLDPaths(instance, actionBody)
+if connections and len(connections) == 1:
-variable = self.ExtractModifier(instance, instance.getVariable())
+expression = self.ComputeFBDExpression(actionBody, connections[0])
-expression = self.ComputeLDExpression(paths, True)
+self.SFCNetworks["Actions"][action_name] = self.Program + "  %s := %s;\n"%(var, expression)
-action_infos["content"] = self.Program + "  %s := %s;"%(variable, expression)
+self.Program = ""
-self.Program = ""
+elif actionType == "LD":
-else:
+for instance in actionbody.getContentInstances():
-action_infos["content"] = action["value"]
+if isinstance(instance, plcopen.coil):
-self.Steps[step_name]["actions"].append(action_infos)
+paths = self.GenerateLDPaths(instance, actionBody)
+variable = self.ExtractModifier(instance, instance.getVariable())
-def GenerateSFCTransitions(self, transition, pou):
+expression = self.ComputeLDExpression(paths, True)
-if transition not in self.Transitions:
+self.SFCNetworks["Actions"][action_name] = self.Program + "  %s := %s;\n"%(variable, expression)
+self.Program = ""
+def GenerateSFCTransition(self, transition, pou):
+if transition not in self.SFCNetworks["Transitions"].keys():
+steps = []
 connections = transition.connectionPointIn.getConnections()
 if len(connections) == 1:
 instanceLocalId = connections[0].getRefLocalId()
 instance = pou.body.getContentInstance(instanceLocalId)
 if isinstance(instance, plcopen.step):
-step_name = instance.getName()
+self.GenerateSFCStep(instance, pou)
-if step_name not in self.Steps:
+steps.append(instance.getName())
-self.GenerateSFCSteps(instance, pou)
 elif isinstance(instance, plcopen.selectionDivergence):
 divergence_connections = instance.connectionPointIn.getConnections()
 if len(divergence_connections) == 1:
 stepLocalId = divergence_connections[0].getRefLocalId()
 divergence_instance = pou.body.getContentInstance(stepLocalId)
 if isinstance(divergence_instance, plcopen.step):
-step_name = divergence_instance.getName()
+self.GenerateSFCStep(divergence_instance, pou)
-if step_name not in self.Steps:
+steps.append(divergence_instance.getName())
-self.GenerateSFCSteps(divergence_instance, pou)
+transition_infos = {"from": [], "to" : []}
-if step_name in self.Steps:
+transitionValues = transition.getConditionContent()
-transition_infos = {"targets" : []}
+if transitionValues["type"] == "inline":
-transitionValues = transition.getConditionContent()
+transition_infos["content"] = "\n    := %s;\n"%transitionValues["value"]
-transition_infos["condition"] = transitionValues["value"]
+else:
-if transitionValues["type"] == "inline":
+transitionContent = pou.getTransition(transitionValues["value"])
-transition_infos["compute"] = ""
+transitionType = transitionContent.getBodyType()
-else:
+transitionBody = transitionContent.getBody()
-transitionContent = pou.getTransition(transitionValues["value"])
+if transitionType == "IL":
-transitionType = transitionContent.getBodyType()
+transition_infos["content"] = ":\n%s\n"%ReIndentText(transitionBody.getText(), 4)
-transitionBody = transitionContent.getBody()
+elif transitionType == "ST":
-if transitionType in ["ST", "IL"]:
+transition_infos["content"] = "\n%s\n"%ReIndentText(transitionBody.getText(), 4)
-transition_infos["compute"] = "%s\n"%transitionContent.getText()
+elif conditionType == "FBD":
-elif conditionType == "FBD":
+for instance in transitionBody.getContentInstances():
-for instance in conditionBody.getContentInstances():
+if isinstance(instance, plcopen.outVariable):
-if isinstance(instance, plcopen.outVariable):
+connections = instance.connectionPointIn.getConnections()
-var = instance.getExpression()
+if connections and len(connections) == 1:
-connections = instance.connectionPointIn.getConnections()
+expression = self.ComputeFBDExpression(actionBody, connections[0])
-if connections and len(connections) == 1:
+transition_infos["content"] = "\n    := %s;\n"%(var, expression)
-expression = self.ComputeFBDExpression(actionBody, connections[0])
+elif actionType == "LD":
-transition_infos["compute"] = self.Program + ":= %s;\n"%(var, expression)
+for instance in transitionbody.getContentInstances():
-self.Program = ""
+if isinstance(instance, plcopen.coil):
-elif actionType == "LD":
+paths = self.GenerateLDPaths(instance, conditionBody)
-for instance in conditionbody.getContentInstances():
+expression = self.ComputeLDExpression(paths, True)
-if isinstance(instance, plcopen.coil):
+transition_infos["content"] = "\n    := %s;\n"%expression
-paths = self.GenerateLDPaths(instance, conditionBody)
+for step_name in steps:
-variable = self.ExtractModifier(instance, instance.getVariable())
+if step_name in self.SFCNetworks["Steps"].keys():
-expression = self.ComputeLDExpression(paths, True)
+transition_infos["from"].append(step_name)
-transition_infos["compute"] = self.Program + ":= %s;\n"%(variable, expression)
+self.SFCNetworks["Steps"][step_name]["transitions"].append(transition)
-self.Program = ""
+self.SFCNetworks["Transitions"][transition] = transition_infos
-self.Steps[step_name]["transitions"].append(transition_infos)
-self.Transitions[transition] = transition_infos
+def ComputeSFCStep(self, step_name):
+if step_name in self.SFCNetworks["Steps"].keys():
-def GenerateSFCStepOrder(self, name, path):
+step_infos = self.SFCNetworks["Steps"].pop(step_name)
-self.Order.append(name)
+if step_infos["initial"]:
-for transition in self.Steps[name]["transitions"]:
+self.Program += "  INITIAL_STEP %s:\n"%step_name
-for target in transition["targets"]:
+else:
-if target not in self.Order or target not in path:
+self.Program += "  STEP %s:\n"%step_name
-if target in self.Order:
+actions = []
-self.Order.remove(target)
+for action_infos in step_infos["actions"]:
-self.GenerateSFCStepOrder(target, path + [name])
+actions.append(action_infos["content"])
+self.Program += "    %(content)s(%(qualifier)s"%action_infos
+if "duration" in action_infos:
+self.Program += ", %(duration)s"%action_infos
+if "indicator" in action_infos:
+self.Program += ", %(indicator)s"%action_infos
+self.Program += ");\n"
+self.Program += "  END_STEP\n\n"
+for action in actions:
+self.ComputeSFCAction(action)
+for transition in step_infos["transitions"]:
+self.ComputeSFCTransition(transition)
+def ComputeSFCAction(self, action_name):
+if action_name in self.SFCNetworks["Actions"].keys():
+action_content = self.SFCNetworks["Actions"].pop(action_name)
+self.Program += "  ACTION %s:\n%s  END_ACTION\n\n"%(action_name, action_content)
+def ComputeSFCTransition(self, transition):
+if transition in self.SFCNetworks["Transitions"].keys():
+transition_infos = self.SFCNetworks["Transitions"].pop(transition)
+self.Program += "  TRANSITION FROM "
+if len(transition_infos["from"]) > 1:
+self.Program += "(%s)"%", ".join(transition_infos["from"])
+else:
+self.Program += "%s"%transition_infos["from"][0]
+self.Program += " TO "
+if len(transition_infos["to"]) > 1:
+self.Program += "(%s)"%", ".join(transition_infos["to"])
+else:
+self.Program += "%s"%transition_infos["to"][0]
+self.Program += transition_infos["content"]
+self.Program += "  END_TRANSITION\n\n"
+for step_name in transition_infos["to"]:
+self.ComputeSFCStep(step_name)
 def ComputeLDExpression(self, paths, first = False):
 if type(paths) == TupleType:
 if None in paths:
 return "TRUE"
 else:
 elif edge.getValue() == "falling":
 return self.AddTrigger("F_TRIG", text)
 return text
 def AddTrigger(self, edge, text):
-if ("VAR", False, False) not in self.Interface:
+if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] or self.Interface[-1][2]:
-self.Interface[("VAR", False, False)] = {}
+self.Interface.append(("VAR", False, False, []))
-if type not in self.Interface[("VAR", False, False)]:
-self.Interface[("VAR", False, False)][edge] = []
 i = 1
 name = "%s%d"%(edge, i)
-while name in self.Interface[("VAR", False, False)][edge]:
+while self.IsAlreadyDefined(name):
 i += 1
 name = "%s%d"%(edge, i)
-self.Interface[("VAR", False, False)][edge].append(name)
+self.Interface[-1][3].append((edge, name))
 self.Program += "  %s(CLK := %s);\n"%(name, text)
 return "%s.Q"%name
 def GenerateSTProgram(self):
 program = ""
-if "returnType" in self.Interface:
+if self.ReturnType:
-program += "%s %s : %s\n"%(self.Type, self.Name, self.Interface["returnType"])
+program += "%s %s : %s\n"%(self.Type, self.Name, self.ReturnType)
 else:
 program += "%s %s\n"%(self.Type, self.Name)
-for values, variables in self.Interface.items():
+for list_type, retain, constant, variables in self.Interface:
-if values != "returnType":
+program += "  %s"%list_type
-program += "  %s"%values[0]
+if retain:
-if values[1]:
+program += " RETAIN"
-program += " RETAIN"
+if constant:
-if values[2]:
+program += " CONSTANT"
-program += " CONSTANT"
+program += "\n"
-program += "\n"
+for var_type, var_name in variables:
-for vartype, list in variables.items():
+program += "    %s : %s;\n"%(var_name, var_type)
-program += "    %s : %s;\n"%(", ".join(list), vartype)
+program += "  END_%s\n"%list_type
-program += "  END_%s\n"%values[0]
 program += "\n"
 program += self.Program
 program += "END_%s\n\n"%self.Type
 return program

changeset 1	e9d01d824086
parent 0	b622defdfd98
child 2	93bc4c2cf376