beremiz: comparison PLCGenerator.py

equal deleted inserted replaced

-:d2e979738700
+:ec153828ded2
 from types import *
 import re
 # Dictionary associating PLCOpen variable categories to the corresponding
 # IEC 61131-3 variable categories
-varTypeNames = {"localVars" : "VAR", "tempVars" : "VAR_TEMP", "inputVars" : "VAR_INPUT",
+varTypeNames = {"localVars": "VAR", "tempVars": "VAR_TEMP", "inputVars": "VAR_INPUT",
-"outputVars" : "VAR_OUTPUT", "inOutVars" : "VAR_IN_OUT", "externalVars" : "VAR_EXTERNAL",
+"outputVars": "VAR_OUTPUT", "inOutVars": "VAR_IN_OUT", "externalVars": "VAR_EXTERNAL",
-"globalVars" : "VAR_GLOBAL", "accessVars" : "VAR_ACCESS"}
+"globalVars": "VAR_GLOBAL", "accessVars": "VAR_ACCESS"}
 # Dictionary associating PLCOpen POU categories to the corresponding
 # IEC 61131-3 POU categories
-pouTypeNames = {"function" : "FUNCTION", "functionBlock" : "FUNCTION_BLOCK", "program" : "PROGRAM"}
+pouTypeNames = {"function": "FUNCTION", "functionBlock": "FUNCTION_BLOCK", "program": "PROGRAM"}
 errorVarTypes = {
 "VAR_INPUT": "var_input",
 "VAR_OUTPUT": "var_output",
 return cmp(ay, by)
 def JoinList(separator, mylist):
 """ Helper for emulate join on element list """
-if len(mylist) > 0 :
+if len(mylist) > 0:
 return reduce(lambda x, y: x + separator + y, mylist)
-else :
+else:
 return mylist
 #-------------------------------------------------------------------------------
 #                  Specific exception for PLC generating errors
 #-------------------------------------------------------------------------------
 ("..", ()),
 ("%s" % dimension.getupper(), (tagname, "range", i, "upper"))]
 for i, dimension in enumerate(basetype_content.getdimension())]
 datatype_def += [("ARRAY [", ())]
 datatype_def += JoinList([(",", ())], dimensions)
-datatype_def += [("] OF " , ()),
+datatype_def += [("] OF ", ()),
 (basetype_name, (tagname, "base"))]
 # Data type is a structure
 elif basetype_content_type == "struct":
 elements = []
 for i, element in enumerate(basetype_content.getvariable()):
 if len(single) == 0:
 msg = _("Source signal has to be defined for single task '{a1}' in resource '{a2}.{a3}'.").\
 format(a1 = task.getname(), a2 = config_name, a3 = resource.getname())
 raise PLCGenException, msg
-if single[0]=='[' and single[-1]==']' :
+if single[0]=='[' and single[-1]==']':
 SNGLKW = "MULTI"
 else:
 SNGLKW = "SINGLE"
 resrce += [(SNGLKW + " := ", ()),
 (single, (tagname, "task", task_number, "single")),
 self.GenerateSFCTransition(instance, pou)
 elif isinstance(instance, JumpStepClass):
 self.GenerateSFCJump(instance, pou)
 if len(self.InitialSteps) > 0 and len(self.SFCComputedBlocks) > 0:
 action_name = "COMPUTE_FUNCTION_BLOCKS"
-action_infos = {"qualifier" : "S", "content" : action_name}
+action_infos = {"qualifier": "S", "content": action_name}
 self.SFCNetworks["Steps"][self.InitialSteps[0]]["actions"].append(action_infos)
 self.SFCNetworks["Actions"][action_name] = (self.SFCComputedBlocks, ())
 self.Program = []
 self.IndentLeft()
 for initialstep in self.InitialSteps:
 self.ComputeSFCStep(initialstep)
 else:
-otherInstances = {"outVariables&coils" : [], "blocks" : [], "connectors" : []}
+otherInstances = {"outVariables&coils": [], "blocks": [], "connectors": []}
 orderedInstances = []
 for instance in body.getcontentInstances():
 if isinstance(instance, (OutVariableClass, InOutVariableClass, BlockClass)):
 executionOrderId = instance.getexecutionOrderId()
 if executionOrderId > 0:
 def GenerateSFCStep(self, step, pou):
 step_name = step.getname()
 if step_name not in self.SFCNetworks["Steps"].keys():
 if step.getinitialStep():
 self.InitialSteps.append(step_name)
-step_infos = {"id" : step.getlocalId(),
+step_infos = {"id":          step.getlocalId(),
-"initial" : step.getinitialStep(),
+"initial":     step.getinitialStep(),
-"transitions" : [],
+"transitions": [],
-"actions" : []}
+"actions":     []}
 self.SFCNetworks["Steps"][step_name] = step_infos
 if step.connectionPointIn is not None:
 instances = []
 connections = step.connectionPointIn.getconnections()
 if connections is not None and len(connections) == 1:
 self.GenerateSFCStep(step, pou)
 step_name = step.getname()
 if step_name in self.SFCNetworks["Steps"].keys():
 actions = actionBlock.getactions()
 for i, action in enumerate(actions):
-action_infos = {"id" : actionBlock.getlocalId(),
+action_infos = {"id":        actionBlock.getlocalId(),
-"qualifier" : action["qualifier"],
+"qualifier": action["qualifier"],
-"content" : action["value"],
+"content":   action["value"],
-"num" : i}
+"num":       i}
 if "duration" in action:
 action_infos["duration"] = action["duration"]
 if "indicator" in action:
 action_infos["indicator"] = action["indicator"]
 if action["type"] == "reference":
 steps.append(step)
 elif isinstance(step, SimultaneousConvergenceClass):
 steps.extend(self.ExtractConvergenceInputs(step, pou))
 elif isinstance(instance, SimultaneousConvergenceClass):
 steps.extend(self.ExtractConvergenceInputs(instance, pou))
-transition_infos = {"id" : transition.getlocalId(),
+transition_infos = {"id":       transition.getlocalId(),
 "priority": transition.getpriority(),
-"from": [],
+"from":     [],
-"to" : [],
+"to":       [],
-"content": []}
+"content":  []}
 self.SFCNetworks["Transitions"][transition] = transition_infos
 transitionValues = transition.getconditionContent()
 if transitionValues["type"] == "inline":
 transition_infos["content"] = [("\n%s:= " % self.CurrentIndent, ()),
 (transitionValues["value"], (self.TagName, "transition", transition.getlocalId(), "inline")),
 program += [(" : ", ()),
 (self.ReturnType, (self.TagName, "return"))]
 program += [("\n", ())]
 if len(self.Interface) == 0:
 raise PLCGenException, _("No variable defined in \"%s\" POU") % self.Name
-if len(self.Program) == 0 :
+if len(self.Program) == 0:
 raise PLCGenException, _("No body defined in \"%s\" POU") % self.Name
 var_number = 0
 for list_type, option, located, variables in self.Interface:
 variable_type = errorVarTypes.get(list_type, "var_local")
 program += [("  %s" % list_type, ())]

changeset 1739	ec153828ded2
parent 1736	7e61baa047f0
child 1740	b789b695b5c6