plcopeneditor_history: comparison PLCGenerator.py

equal deleted inserted replaced

-:7ea1f5094df3
+:6a72016d721a
 basetype_name = base_type["name"]
 min_value = basetype_content["value"].range.getlower()
 max_value = basetype_content["value"].range.getupper()
 datatype_def += [(basetype_name, (tagname, "base")),
 (" (", ()),
-("%d"%min_value, (tagname, "lower")),
+("%s"%min_value, (tagname, "lower")),
 ("..", ()),
-("%d"%max_value, (tagname, "upper")),
+("%s"%max_value, (tagname, "upper")),
 (")",())]
 # Data type is an enumerated type
 elif basetype_content["name"] == "enum":
 values = [[(value.getname(), (tagname, "value", i))]
 for i, value in enumerate(basetype_content["value"].values.getvalue())]
 elif base_type["name"] in ["string", "wstring"]:
 basetype_name = base_type["name"].upper()
 # Array derived directly from an elementary type
 else:
 basetype_name = base_type["name"]
-dimensions = [[("%d"%dimension.getlower(), (tagname, "range", i, "lower")),
+dimensions = [[("%s"%dimension.getlower(), (tagname, "range", i, "lower")),
 ("..", ()),
-("%d"%dimension.getupper(), (tagname, "range", i, "upper"))]
+("%s"%dimension.getupper(), (tagname, "range", i, "upper"))]
 for i, dimension in enumerate(basetype_content["value"].getdimension())]
 datatype_def += [("ARRAY [", ())]
 datatype_def += JoinList([(",", ())], dimensions)
 datatype_def += [("] OF " , ()),
 (basetype_name, (tagname, "base"))]
 (single, (tagname, "task", task_number, "single")),
 (",", ())]
 # Interval argument if exists
 interval = task.getinterval()
 if interval:
-resrce += [("INTERVAL := t#", ())]
+resrce += [("INTERVAL := ", ()),
-if interval.hour != 0:
+(interval, (tagname, "task", task_number, "interval")),
-resrce += [("%dh"%interval.hour, (tagname, "task", task_number, "interval", "hour"))]
+(",", ())]
-if interval.minute != 0:
+##                resrce += [("INTERVAL := t#", ())]
-resrce += [("%dm"%interval.minute, (tagname, "task", task_number, "interval", "minute"))]
+##                if interval.hour != 0:
-if interval.second != 0:
+##                    resrce += [("%dh"%interval.hour, (tagname, "task", task_number, "interval", "hour"))]
-resrce += [("%ds"%interval.second, (tagname, "task", task_number, "interval", "second"))]
+##                if interval.minute != 0:
-if interval.microsecond != 0:
+##                    resrce += [("%dm"%interval.minute, (tagname, "task", task_number, "interval", "minute"))]
-resrce += [("%dms"%(interval.microsecond / 1000), (tagname, "task", task_number, "interval", "millisecond"))]
+##                if interval.second != 0:
-resrce += [(",", ())]
+##                    resrce += [("%ds"%interval.second, (tagname, "task", task_number, "interval", "second"))]
+##                if interval.microsecond != 0:
+##                    resrce += [("%dms"%(interval.microsecond / 1000), (tagname, "task", task_number, "interval", "millisecond"))]
+##                resrce += [(",", ())]
 # Priority argument
 resrce += [("PRIORITY := ", ()),
 ("%d"%task.getpriority(), (tagname, "task", task_number, "priority")),
 (");\n", ())]
 task_number += 1
 resrce += [("    PROGRAM ", ()),
 (instance.getname(), (tagname, "instance", instance_number, "name")),
 (" WITH ", ()),
 (task.getname(), (tagname, "instance", instance_number, "task")),
 (" : ", ()),
-(instance.gettype(), (tagname, "instance", instance_number, "type")),
+(instance.gettypeName(), (tagname, "instance", instance_number, "type")),
 (";\n", ())]
 instance_number += 1
 # Generate any program assign to no task
 for instance in resource.getpouInstance():
 resrce += [("    PROGRAM ", ()),
 (instance.getname(), (tagname, "instance", instance_number, "name")),
 (" : ", ()),
-(instance.gettype(), (tagname, "instance", instance_number, "type")),
+(instance.gettypeName(), (tagname, "instance", instance_number, "type")),
 (";\n", ())]
 instance_number += 1
 resrce += [("  END_RESOURCE\n", ())]
 return resrce
 def ComputeInterface(self, pou):
 interface = pou.getinterface()
 if interface is not None:
 body = pou.getbody()
+if isinstance(body, ListType):
+body = body[0]
 body_content = body.getcontent()
 if self.Type == "FUNCTION":
 returntype_content = interface.getreturnType().getcontent()
 if returntype_content["name"] == "derived":
 self.ReturnType = returntype_content["value"].getname()
 self.Interface.append((varTypeNames[varlist["name"]], varlist["value"].getretain(),
 varlist["value"].getconstant(), True, located))
 def ComputeConnectionTypes(self, pou):
 body = pou.getbody()
+if isinstance(body, ListType):
+body = body[0]
 body_content = body.getcontent()
 body_type = body_content["name"]
 if body_type in ["FBD", "LD", "SFC"]:
 for instance in body.getcontentInstances():
 if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_outVariable, plcopen.fbdObjects_inOutVariable)):
 self.ConnectionTypes[connection] = var_type
 else:
 raise PLCGenException, "No connector found corresponding to \"%s\" continuation in \"%s\" POU"%(name, self.Name)
 elif isinstance(instance, plcopen.fbdObjects_block):
 block_infos = self.GetBlockType(instance.gettypeName())
-undefined = {}
+if block_infos is not None:
-for variable in instance.outputVariables.getvariable():
+undefined = {}
-output_name = variable.getformalParameter()
+for variable in instance.outputVariables.getvariable():
-if output_name == "ENO":
+output_name = variable.getformalParameter()
-for connection in self.ExtractRelatedConnections(variable.connectionPointOut):
+if output_name == "ENO":
-self.ConnectionTypes[connection] = "BOOL"
+for connection in self.ExtractRelatedConnections(variable.connectionPointOut):
-else:
+self.ConnectionTypes[connection] = "BOOL"
-for oname, otype, oqualifier in block_infos["outputs"]:
+else:
-if output_name == oname:
+for oname, otype, oqualifier in block_infos["outputs"]:
-if otype.startswith("ANY"):
+if output_name == oname:
-if not undefined.has_key(otype):
+if otype.startswith("ANY"):
-undefined[otype] = []
+if not undefined.has_key(otype):
-undefined[otype].append(variable.connectionPointOut)
+undefined[otype] = []
-elif not self.ConnectionTypes.has_key(variable.connectionPointOut):
+undefined[otype].append(variable.connectionPointOut)
-for connection in self.ExtractRelatedConnections(variable.connectionPointOut):
+elif not self.ConnectionTypes.has_key(variable.connectionPointOut):
-self.ConnectionTypes[connection] = otype
+for connection in self.ExtractRelatedConnections(variable.connectionPointOut):
-for variable in instance.inputVariables.getvariable():
+self.ConnectionTypes[connection] = otype
-input_name = variable.getformalParameter()
+for variable in instance.inputVariables.getvariable():
-if input_name == "EN":
+input_name = variable.getformalParameter()
-for connection in self.ExtractRelatedConnections(variable.connectionPointIn):
+if input_name == "EN":
-self.ConnectionTypes[connection] = "BOOL"
+for connection in self.ExtractRelatedConnections(variable.connectionPointIn):
-for iname, itype, iqualifier in block_infos["inputs"]:
+self.ConnectionTypes[connection] = "BOOL"
-if input_name == iname:
+for iname, itype, iqualifier in block_infos["inputs"]:
-connected = self.GetConnectedConnector(variable.connectionPointIn, body)
+if input_name == iname:
-if itype.startswith("ANY"):
+connected = self.GetConnectedConnector(variable.connectionPointIn, body)
-if not undefined.has_key(itype):
+if itype.startswith("ANY"):
-undefined[itype] = []
+if not undefined.has_key(itype):
-undefined[itype].append(variable.connectionPointIn)
+undefined[itype] = []
-if connected:
+undefined[itype].append(variable.connectionPointIn)
-undefined[itype].append(connected)
+if connected:
+undefined[itype].append(connected)
+else:
+self.ConnectionTypes[variable.connectionPointIn] = itype
+if connected and not self.ConnectionTypes.has_key(connected):
+for connection in self.ExtractRelatedConnections(connected):
+self.ConnectionTypes[connection] = itype
+for var_type, connections in undefined.items():
+related = []
+for connection in connections:
+if self.ConnectionTypes.has_key(connection):
+var_type = self.ConnectionTypes[connection]
 else:
-self.ConnectionTypes[variable.connectionPointIn] = itype
+related.extend(self.ExtractRelatedConnections(connection))
-if connected and not self.ConnectionTypes.has_key(connected):
+if var_type.startswith("ANY") and len(related) > 0:
-for connection in self.ExtractRelatedConnections(connected):
+self.RelatedConnections.append(related)
-self.ConnectionTypes[connection] = itype
-for var_type, connections in undefined.items():
-related = []
-for connection in connections:
-if self.ConnectionTypes.has_key(connection):
-var_type = self.ConnectionTypes[connection]
 else:
-related.extend(self.ExtractRelatedConnections(connection))
+for connection in related:
-if var_type.startswith("ANY") and len(related) > 0:
+self.ConnectionTypes[connection] = var_type
-self.RelatedConnections.append(related)
+else:
-else:
+raise PLCGenException, _("No informations found for \"%s\" block")%(instance.gettypeName())
-for connection in related:
-self.ConnectionTypes[connection] = var_type
 def ComputeProgram(self, pou):
 body = pou.getbody()
+if isinstance(body, ListType):
+body = body[0]
 body_content = body.getcontent()
 body_type = body_content["name"]
 if body_type in ["IL","ST"]:
 text = body_content["value"].gettext()
 self.ParentGenerator.GeneratePouProgramInText(text.upper())
 connectionPointIn = divergence.getconnectionPointIn()
 if connectionPointIn:
 connections = connectionPointIn.getconnections()
 if connections is not None and len(connections) == 1:
 instanceLocalId = connections[0].getrefLocalId()
-return pou.body.getcontentInstance(instanceLocalId)
+body = pou.getbody()
+if isinstance(body, ListType):
+body = body[0]
+return body.getcontentInstance(instanceLocalId)
 return None
 def ExtractConvergenceInputs(self, convergence, pou):
 instances = []
 for connectionPointIn in convergence.getconnectionPointIn():
 connections = connectionPointIn.getconnections()
 if len(connections) == 1:
 instanceLocalId = connections[0].getrefLocalId()
-instances.append(pou.body.getcontentInstance(instanceLocalId))
+body = pou.getbody()
+if isinstance(body, ListType):
+body = body[0]
+instances.append(body.getcontentInstance(instanceLocalId))
 return instances
 def GenerateSFCStep(self, step, pou):
 step_name = step.getname()
 if step_name not in self.SFCNetworks["Steps"].keys():
 if step.connectionPointIn:
 instances = []
 connections = step.connectionPointIn.getconnections()
 if len(connections) == 1:
 instanceLocalId = connections[0].getrefLocalId()
-instance = pou.body.getcontentInstance(instanceLocalId)
+body = pou.getbody()
+if isinstance(body, ListType):
+body = body[0]
+instance = body.getcontentInstance(instanceLocalId)
 if isinstance(instance, plcopen.sfcObjects_transition):
 instances.append(instance)
 elif isinstance(instance, plcopen.sfcObjects_selectionConvergence):
 instances.extend(self.ExtractConvergenceInputs(instance, pou))
 elif isinstance(instance, plcopen.sfcObjects_simultaneousDivergence):
 if jump.connectionPointIn:
 instances = []
 connections = jump.connectionPointIn.getconnections()
 if len(connections) == 1:
 instanceLocalId = connections[0].getrefLocalId()
-instance = pou.body.getcontentInstance(instanceLocalId)
+body = pou.getbody()
+if isinstance(body, ListType):
+body = body[0]
+instance = body.getcontentInstance(instanceLocalId)
 if isinstance(instance, plcopen.sfcObjects_transition):
 instances.append(instance)
 elif isinstance(instance, plcopen.sfcObjects_selectionConvergence):
 instances.extend(self.ExtractConvergenceInputs(instance, pou))
 elif isinstance(instance, plcopen.sfcObjects_simultaneousDivergence):
 def GenerateSFCStepActions(self, actionBlock, pou):
 connections = actionBlock.connectionPointIn.getconnections()
 if connections is not None and len(connections) == 1:
 stepLocalId = connections[0].getrefLocalId()
-step = pou.body.getcontentInstance(stepLocalId)
+body = pou.getbody()
+if isinstance(body, ListType):
+body = body[0]
+step = body.getcontentInstance(stepLocalId)
 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):
 if transition not in self.SFCNetworks["Transitions"].keys():
 steps = []
 connections = transition.connectionPointIn.getconnections()
 if connections is not None and len(connections) == 1:
 instanceLocalId = connections[0].getrefLocalId()
-instance = pou.body.getcontentInstance(instanceLocalId)
+body = pou.getbody()
+if isinstance(body, ListType):
+body = body[0]
+instance = body.getcontentInstance(instanceLocalId)
 if isinstance(instance, plcopen.sfcObjects_step):
 steps.append(instance)
 elif isinstance(instance, plcopen.sfcObjects_selectionDivergence):
 step = self.ExtractDivergenceInput(instance, pou)
 if step:
 self.SFCComputedBlocks += self.Program
 self.Program = []
 self.TagName = previous_tagname
 elif transitionValues["type"] == "connection":
 body = pou.getbody()
+if isinstance(body, ListType):
+body = body[0]
 connections = transition.getconnections()
 if connections is not None:
 expression = self.ComputeExpression(body, connections)
 transition_infos["content"] = [("\n%s:= "%self.CurrentIndent, ())] + expression + [(";\n", ())]
 self.SFCComputedBlocks += self.Program

changeset 389	6a72016d721a
parent 370	23af12b5a9fb
child 391	07447ee3538e