beremiz: comparison PLCGenerator.py

equal deleted inserted replaced

-:85ce56758900
+:3d7fa2257b24
 bx, by = int(b.getx()), int(b.gety())
 if abs(ay - by) < 10:
 return cmp(ax, bx)
 else:
 return cmp(ay, by)
+# Helper for emulate join on element list
+def JoinList(separator, mylist):
+if len(mylist) > 0 :
+return reduce(lambda x, y: x + separator + y, mylist)
+else :
+return mylist
 #-------------------------------------------------------------------------------
 #                  Specific exception for PLC generating errors
 #-------------------------------------------------------------------------------
 if vartype_content.getLocalTag() == "derived":
 var_type = vartype_content.getname()
 blocktype = self.GetBlockType(var_type)
 if blocktype is not None:
 self.ParentGenerator.GeneratePouProgram(var_type)
-if body_type in ["FBD", "LD", "SFC"]:
+variables.append((var_type, var.getname(), None, None))
-block = pou.getinstanceByName(var.getname())
-else:
-block = None
-for variable in blocktype["initialise"](var_type, var.getname(), block):
-if variable[2] is not None:
-located.append(variable)
-else:
-variables.append(variable)
 else:
 self.ParentGenerator.GenerateDataType(var_type)
 initial = var.getinitialValue()
-if initial:
+if initial is not None:
 initial_value = initial.getvalue()
 else:
 initial_value = None
 address = var.getaddress()
 if address is not None:
 else:
 variables.append((vartype_content.getname(), var.getname(), None, initial_value))
 else:
 var_type = var.gettypeAsText()
 initial = var.getinitialValue()
-if initial:
+if initial is not None:
 initial_value = initial.getvalue()
 else:
 initial_value = None
 address = var.getaddress()
 if address is not None:
 if block_infos is None:
 block_infos = self.GetBlockType(block_type)
 if block_infos is None:
 raise PLCGenException, _("Undefined block type \"%s\" in \"%s\" POU")%(block_type, self.Name)
 try:
-block_infos["generate"](self, instance, block_infos, body, None)
+self.GenerateBlock(instance, block_infos, body, None)
 except ValueError, e:
 raise PLCGenException, e.message
 elif isinstance(instance, ConnectorClass):
 connector = instance.getname()
 if self.ComputedConnectors.get(connector, None):
 for num in uncomputed_index:
 factorized_paths.append(paths[num])
 factorized_paths.sort()
 return factorized_paths
+def GenerateBlock(self, block, block_infos, body, link, order=False, to_inout=False):
+body_type = body.getcontent().getLocalTag()
+name = block.getinstanceName()
+type = block.gettypeName()
+executionOrderId = block.getexecutionOrderId()
+input_variables = block.inputVariables.getvariable()
+output_variables = block.outputVariables.getvariable()
+inout_variables = {}
+for input_variable in input_variables:
+for output_variable in output_variables:
+if input_variable.getformalParameter() == output_variable.getformalParameter():
+inout_variables[input_variable.getformalParameter()] = ""
+input_names = [input[0] for input in block_infos["inputs"]]
+output_names = [output[0] for output in block_infos["outputs"]]
+if block_infos["type"] == "function":
+if not self.ComputedBlocks.get(block, False) and not order:
+self.ComputedBlocks[block] = True
+connected_vars = []
+if not block_infos["extensible"]:
+input_connected = dict([("EN", None)] +
+[(input_name, None) for input_name in input_names])
+for variable in input_variables:
+parameter = variable.getformalParameter()
+if input_connected.has_key(parameter):
+input_connected[parameter] = variable
+if input_connected["EN"] is None:
+input_connected.pop("EN")
+input_parameters = input_names
+else:
+input_parameters = ["EN"] + input_names
+else:
+input_connected = dict([(variable.getformalParameter(), variable)
+for variable in input_variables])
+input_parameters = [variable.getformalParameter()
+for variable in input_variables]
+one_input_connected = False
+all_input_connected = True
+for i, parameter in enumerate(input_parameters):
+variable = input_connected.get(parameter)
+if variable is not None:
+input_info = (self.TagName, "block", block.getlocalId(), "input", i)
+connections = variable.connectionPointIn.getconnections()
+if connections is not None:
+if parameter != "EN":
+one_input_connected = True
+if inout_variables.has_key(parameter):
+expression = self.ComputeExpression(body, connections, executionOrderId > 0, True)
+if expression is not None:
+inout_variables[parameter] = value
+else:
+expression = self.ComputeExpression(body, connections, executionOrderId > 0)
+if expression is not None:
+connected_vars.append(([(parameter, input_info), (" := ", ())],
+self.ExtractModifier(variable, expression, input_info)))
+else:
+all_input_connected = False
+else:
+all_input_connected = False
+if len(output_variables) > 1 or not all_input_connected:
+vars = [name + value for name, value in connected_vars]
+else:
+vars = [value for name, value in connected_vars]
+if one_input_connected:
+for i, variable in enumerate(output_variables):
+parameter = variable.getformalParameter()
+if not inout_variables.has_key(parameter) and parameter in output_names + ["", "ENO"]:
+if variable.getformalParameter() == "":
+variable_name = "%s%d"%(type, block.getlocalId())
+else:
+variable_name = "%s%d_%s"%(type, block.getlocalId(), parameter)
+if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] is not None or self.Interface[-1][2]:
+self.Interface.append(("VAR", None, False, []))
+if variable.connectionPointOut in self.ConnectionTypes:
+self.Interface[-1][3].append((self.ConnectionTypes[variable.connectionPointOut], variable_name, None, None))
+else:
+self.Interface[-1][3].append(("ANY", variable_name, None, None))
+if len(output_variables) > 1 and parameter not in ["", "OUT"]:
+vars.append([(parameter, (self.TagName, "block", block.getlocalId(), "output", i)),
+(" => %s"%variable_name, ())])
+else:
+output_info = (self.TagName, "block", block.getlocalId(), "output", i)
+output_name = variable_name
+self.Program += [(self.CurrentIndent, ()),
+(output_name, output_info),
+(" := ", ()),
+(type, (self.TagName, "block", block.getlocalId(), "type")),
+("(", ())]
+self.Program += JoinList([(", ", ())], vars)
+self.Program += [(");\n", ())]
+else:
+self.Warnings.append(_("\"%s\" function cancelled in \"%s\" POU: No input connected")%(type, self.TagName.split("::")[-1]))
+elif block_infos["type"] == "functionBlock":
+if not self.ComputedBlocks.get(block, False) and not order:
+self.ComputedBlocks[block] = True
+vars = []
+offset_idx = 0
+for variable in input_variables:
+parameter = variable.getformalParameter()
+if parameter in input_names or parameter == "EN":
+if parameter == "EN":
+input_idx = 0
+offset_idx = 1
+else:
+input_idx = offset_idx + input_names.index(parameter)
+input_info = (self.TagName, "block", block.getlocalId(), "input", input_idx)
+connections = variable.connectionPointIn.getconnections()
+if connections is not None:
+expression = self.ComputeExpression(body, connections, executionOrderId > 0, inout_variables.has_key(parameter))
+if expression is not None:
+vars.append([(parameter, input_info),
+(" := ", ())] + self.ExtractModifier(variable, expression, input_info))
+self.Program += [(self.CurrentIndent, ()),
+(name, (self.TagName, "block", block.getlocalId(), "name")),
+("(", ())]
+self.Program += JoinList([(", ", ())], vars)
+self.Program += [(");\n", ())]
+if link is not None:
+connectionPoint = link.getposition()[-1]
+output_parameter = link.getformalParameter()
+else:
+connectionPoint = None
+output_parameter = None
+output_variable = None
+output_idx = 0
+if output_parameter is not None:
+if output_parameter in output_names or output_parameter == "ENO":
+for variable in output_variables:
+if variable.getformalParameter() == output_parameter:
+output_variable = variable
+if output_parameter != "ENO":
+output_idx = output_names.index(output_parameter)
+else:
+for i, variable in enumerate(output_variables):
+blockPointx, blockPointy = variable.connectionPointOut.getrelPositionXY()
+if (connectionPoint is None or
+block.getx() + blockPointx == connectionPoint.getx() and
+block.gety() + blockPointy == connectionPoint.gety()):
+output_variable = variable
+output_parameter = variable.getformalParameter()
+output_idx = i
+if output_variable is not None:
+if block_infos["type"] == "function":
+output_info = (self.TagName, "block", block.getlocalId(), "output", output_idx)
+if inout_variables.has_key(output_parameter):
+output_value = inout_variables[output_parameter]
+else:
+if output_parameter == "":
+output_name = "%s%d"%(type, block.getlocalId())
+else:
+output_name = "%s%d_%s"%(type, block.getlocalId(), output_parameter)
+output_value = [(output_name, output_info)]
+return self.ExtractModifier(output_variable, output_value, output_info)
+if block_infos["type"] == "functionBlock":
+output_info = (self.TagName, "block", block.getlocalId(), "output", output_idx)
+output_name = self.ExtractModifier(output_variable, [("%s.%s"%(name, output_parameter), output_info)], output_info)
+if to_inout:
+variable_name = "%s_%s"%(name, output_parameter)
+if not self.IsAlreadyDefined(variable_name):
+if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] is not None or self.Interface[-1][2]:
+self.Interface.append(("VAR", None, False, []))
+if variable.connectionPointOut in self.ConnectionTypes:
+self.Interface[-1][3].append(
+(self.ConnectionTypes[output_variable.connectionPointOut], variable_name, None, None))
+else:
+self.Interface[-1][3].append(("ANY", variable_name, None, None))
+self.Program += [(self.CurrentIndent, ()),
+("%s := "%variable_name, ())]
+self.Program += output_name
+self.Program += [(";\n", ())]
+return [(variable_name, ())]
+return output_name
+if link is not None:
+if output_parameter is None:
+output_parameter = ""
+if name:
+blockname = "%s(%s)" % (name, type)
+else:
+blockname = type
+raise ValueError, _("No output %s variable found in block %s in POU %s. Connection must be broken")  % \
+(output_parameter, blockname, self.Name)
 def GeneratePaths(self, connections, body, order = False, to_inout = False):
 paths = []
 for connection in connections:
 localId = connection.getrefLocalId()
 next = body.getcontentInstance(localId)
 if block_infos is None:
 block_infos = self.GetBlockType(block_type)
 if block_infos is None:
 raise PLCGenException, _("Undefined block type \"%s\" in \"%s\" POU")%(block_type, self.Name)
 try:
-paths.append(str(block_infos["generate"](self, next, block_infos, body, connection, order, to_inout)))
+paths.append(str(self.GenerateBlock(next, block_infos, body, connection, order, to_inout)))
 except ValueError, e:
 raise PLCGenException, e.message
 elif isinstance(next, ContinuationClass):
 name = next.getname()
 computed_value = self.ComputedConnectors.get(name, None)
 self.ComputeConnectionTypes(pou)
 self.ComputeProgram(pou)
 program = [("%s "%self.Type, ()),
 (self.Name, (self.TagName, "name"))]
-if self.ReturnType:
+if self.ReturnType is not None:
 program += [(" : ", ()),
 (self.ReturnType, (self.TagName, "return"))]
 program += [("\n", ())]
 if len(self.Interface) == 0:
 raise PLCGenException, _("No variable defined in \"%s\" POU")%self.Name

changeset 1310	3d7fa2257b24
parent 1298	f034fb2b1aab
child 1315	ff14a66bbd12