113 expression = self.ComputeFBDExpression(body, connections[0]) |
113 expression = self.ComputeFBDExpression(body, connections[0]) |
114 self.Program += " %s := %s;\n"%(var, expression) |
114 self.Program += " %s := %s;\n"%(var, expression) |
115 elif body_type == "LD": |
115 elif body_type == "LD": |
116 for instance in body.getContentInstances(): |
116 for instance in body.getContentInstances(): |
117 if isinstance(instance, plcopen.coil): |
117 if isinstance(instance, plcopen.coil): |
118 paths = self.GenerateLDPaths(instance, body) |
118 paths = self.GenerateLDPaths(instance.connectionPointIn.getConnections(), body) |
119 variable = self.ExtractModifier(instance, instance.getVariable()) |
119 variable = self.ExtractModifier(instance, instance.getVariable()) |
120 expression = self.ComputeLDExpression(paths, True) |
120 expression = self.ComputeLDExpression(paths, True) |
121 self.Program += " %s := %s;\n"%(variable, expression) |
121 self.Program += " %s := %s;\n"%(variable, expression) |
122 elif body_type == "SFC": |
122 elif body_type == "SFC": |
123 for instance in body.getContentInstances(): |
123 for instance in body.getContentInstances(): |
127 self.GenerateSFCStepActions(instance, pou) |
127 self.GenerateSFCStepActions(instance, pou) |
128 elif isinstance(instance, plcopen.transition): |
128 elif isinstance(instance, plcopen.transition): |
129 self.GenerateSFCTransition(instance, pou) |
129 self.GenerateSFCTransition(instance, pou) |
130 elif isinstance(instance, plcopen.jumpStep): |
130 elif isinstance(instance, plcopen.jumpStep): |
131 self.GenerateSFCJump(instance, pou) |
131 self.GenerateSFCJump(instance, pou) |
|
132 if len(self.InitialSteps) > 0: |
|
133 action_name = "COMPUTE_FUNCTION_BLOCKS" |
|
134 action_infos = {"qualifier" : "S", "content" : action_name} |
|
135 self.SFCNetworks["Steps"][self.InitialSteps[0]]["actions"].append(action_infos) |
|
136 self.SFCNetworks["Actions"][action_name] = ReIndentText(self.Program, 4) |
|
137 self.Program = "" |
|
138 else: |
|
139 raise Exception |
132 for initialstep in self.InitialSteps: |
140 for initialstep in self.InitialSteps: |
133 self.ComputeSFCStep(initialstep) |
141 self.ComputeSFCStep(initialstep) |
134 |
142 |
135 def ComputeFBDExpression(self, body, link): |
143 def ComputeFBDExpression(self, body, link): |
136 localid = link.getRefLocalId() |
144 localid = link.getRefLocalId() |
168 blockPointx, blockPointy = variable.connectionPointOut.getRelPosition() |
176 blockPointx, blockPointy = variable.connectionPointOut.getRelPosition() |
169 if instance.getX() + blockPointx == connectionPoint.getX() and instance.getY() + blockPointy == connectionPoint.getY(): |
177 if instance.getX() + blockPointx == connectionPoint.getX() and instance.getY() + blockPointy == connectionPoint.getY(): |
170 return self.ExtractModifier(variable, "%s.%s"%(name, variable.getFormalParameter())) |
178 return self.ExtractModifier(variable, "%s.%s"%(name, variable.getFormalParameter())) |
171 raise ValueError, "No output variable found" |
179 raise ValueError, "No output variable found" |
172 |
180 |
173 def GenerateLDPaths(self, instance, body): |
181 def GenerateLDPaths(self, connections, body): |
174 paths = [] |
182 paths = [] |
175 variable = self.ExtractModifier(instance, instance.getVariable()) |
|
176 connections = instance.connectionPointIn.getConnections() |
|
177 for connection in connections: |
183 for connection in connections: |
178 localId = connection.getRefLocalId() |
184 localId = connection.getRefLocalId() |
179 next = body.getContentInstance(localId) |
185 next = body.getContentInstance(localId) |
180 if isinstance(next, plcopen.leftPowerRail): |
186 if isinstance(next, plcopen.leftPowerRail): |
181 paths.append(None) |
187 paths.append(None) |
182 else: |
188 else: |
183 paths.append(self.GenerateLDPaths(next, body)) |
189 variable = self.ExtractModifier(next, next.getVariable()) |
184 if isinstance(instance, plcopen.coil): |
190 result = self.GenerateLDPaths(next.connectionPointIn.getConnections(), body) |
185 if len(paths) > 1: |
191 if len(result) > 1: |
186 return tuple(paths) |
192 paths.append([variable, tuple(result)]) |
187 else: |
193 elif type(result[0]) == ListType: |
188 return paths |
194 paths.append([variable] + result[0]) |
189 else: |
195 elif result[0]: |
190 if len(paths) > 1: |
196 paths.append([variable, result[0]]) |
191 return [variable, tuple(paths)] |
197 else: |
192 elif type(paths[0]) == ListType: |
198 paths.append(variable) |
193 return [variable] + paths[0] |
199 return paths |
194 elif paths[0]: |
200 |
195 return [variable, paths[0]] |
201 def GetNetworkType(self, connections, body): |
196 else: |
202 network_type = "FBD" |
197 return variable |
203 for connection in connections: |
198 |
204 localId = connection.getRefLocalId() |
|
205 next = body.getContentInstance(localId) |
|
206 if isinstance(next, plcopen.leftPowerRail) or isinstance(next, plcopen.contact): |
|
207 return "LD" |
|
208 elif isinstance(next, plcopen.block): |
|
209 for variable in instance.inputVariables.getVariable(): |
|
210 result = self.GetNetworkType(variable.connectionPointIn.getConnections(), body) |
|
211 if result != "FBD": |
|
212 return result |
|
213 elif isinstance(next, plcopen.inVariable): |
|
214 return "FBD" |
|
215 elif isinstance(next, plcopen.inOutVariable): |
|
216 return self.GetNetworkType(next.connectionPointIn.getConnections(), body) |
|
217 else: |
|
218 return None |
|
219 return "FBD" |
|
220 |
199 def ExtractDivergenceInput(self, divergence, pou): |
221 def ExtractDivergenceInput(self, divergence, pou): |
200 connectionPointIn = divergence.getConnectionPointIn() |
222 connectionPointIn = divergence.getConnectionPointIn() |
201 if connectionPointIn: |
223 if connectionPointIn: |
202 connections = connectionPointIn.getConnections() |
224 connections = connectionPointIn.getConnections() |
203 if len(connections) == 1: |
225 if len(connections) == 1: |
308 self.SFCNetworks["Actions"][action_name] = self.Program + " %s := %s;\n"%(var, expression) |
330 self.SFCNetworks["Actions"][action_name] = self.Program + " %s := %s;\n"%(var, expression) |
309 self.Program = "" |
331 self.Program = "" |
310 elif actionType == "LD": |
332 elif actionType == "LD": |
311 for instance in actionbody.getContentInstances(): |
333 for instance in actionbody.getContentInstances(): |
312 if isinstance(instance, plcopen.coil): |
334 if isinstance(instance, plcopen.coil): |
313 paths = self.GenerateLDPaths(instance, actionBody) |
335 paths = self.GenerateLDPaths(instance.connectionPointIn.getConnections(), actionBody) |
314 variable = self.ExtractModifier(instance, instance.getVariable()) |
336 variable = self.ExtractModifier(instance, instance.getVariable()) |
315 expression = self.ComputeLDExpression(paths, True) |
337 expression = self.ComputeLDExpression(paths, True) |
316 self.SFCNetworks["Actions"][action_name] = self.Program + " %s := %s;\n"%(variable, expression) |
338 self.SFCNetworks["Actions"][action_name] = self.Program + " %s := %s;\n"%(variable, expression) |
317 self.Program = "" |
339 self.Program = "" |
318 |
340 |
336 steps.extend(self.ExtractConvergenceInputs(instance, pou)) |
358 steps.extend(self.ExtractConvergenceInputs(instance, pou)) |
337 transition_infos = {"from": [], "to" : []} |
359 transition_infos = {"from": [], "to" : []} |
338 transitionValues = transition.getConditionContent() |
360 transitionValues = transition.getConditionContent() |
339 if transitionValues["type"] == "inline": |
361 if transitionValues["type"] == "inline": |
340 transition_infos["content"] = "\n := %s;\n"%transitionValues["value"] |
362 transition_infos["content"] = "\n := %s;\n"%transitionValues["value"] |
341 else: |
363 elif transitionValues["type"] == "reference": |
342 transitionContent = pou.getTransition(transitionValues["value"]) |
364 transitionContent = pou.getTransition(transitionValues["value"]) |
343 transitionType = transitionContent.getBodyType() |
365 transitionType = transitionContent.getBodyType() |
344 transitionBody = transitionContent.getBody() |
366 transitionBody = transitionContent.getBody() |
345 if transitionType == "IL": |
367 if transitionType == "IL": |
346 transition_infos["content"] = ":\n%s"%ReIndentText(transitionBody.getText(), 4) |
368 transition_infos["content"] = ":\n%s"%ReIndentText(transitionBody.getText(), 4) |
347 elif transitionType == "ST": |
369 elif transitionType == "ST": |
348 transition_infos["content"] = "\n%s"%ReIndentText(transitionBody.getText(), 4) |
370 transition_infos["content"] = "\n%s"%ReIndentText(transitionBody.getText(), 4) |
349 elif conditionType == "FBD": |
371 elif transitionType == "FBD": |
350 for instance in transitionBody.getContentInstances(): |
372 for instance in transitionBody.getContentInstances(): |
351 if isinstance(instance, plcopen.outVariable): |
373 if isinstance(instance, plcopen.outVariable): |
352 connections = instance.connectionPointIn.getConnections() |
374 connections = instance.connectionPointIn.getConnections() |
353 if connections and len(connections) == 1: |
375 if connections and len(connections) == 1: |
354 expression = self.ComputeFBDExpression(actionBody, connections[0]) |
376 expression = self.ComputeFBDExpression(transitionBody, connections[0]) |
355 transition_infos["content"] = "\n := %s;\n"%(var, expression) |
377 transition_infos["content"] = "\n := %s;\n"%expression |
356 elif actionType == "LD": |
378 elif transitionType == "LD": |
357 for instance in transitionbody.getContentInstances(): |
379 for instance in transitionBody.getContentInstances(): |
358 if isinstance(instance, plcopen.coil): |
380 if isinstance(instance, plcopen.coil): |
359 paths = self.GenerateLDPaths(instance, conditionBody) |
381 paths = self.GenerateLDPaths(instance.connectionPointIn.getConnections(), transitionBody) |
360 expression = self.ComputeLDExpression(paths, True) |
382 expression = self.ComputeLDExpression(paths, True) |
361 transition_infos["content"] = "\n := %s;\n"%expression |
383 transition_infos["content"] = "\n := %s;\n"%expression |
|
384 elif transitionValues["type"] == "connection": |
|
385 body = pou.getBody() |
|
386 connections = transition.getConnections() |
|
387 network_type = self.GetNetworkType(connections, body) |
|
388 if network_type == None: |
|
389 raise Exception |
|
390 if len(connections) > 1 or network_type == "LD": |
|
391 paths = self.GenerateLDPaths(connections, body) |
|
392 expression = self.ComputeLDExpression(paths, True) |
|
393 transition_infos["content"] = "\n := %s;\n"%expression |
|
394 else: |
|
395 expression = self.ComputeFBDExpression(body, connections[0]) |
|
396 transition_infos["content"] = "\n := %s;\n"%expression |
362 for step in steps: |
397 for step in steps: |
363 self.GenerateSFCStep(step, pou) |
398 self.GenerateSFCStep(step, pou) |
364 step_name = step.getName() |
399 step_name = step.getName() |
365 if step_name in self.SFCNetworks["Steps"].keys(): |
400 if step_name in self.SFCNetworks["Steps"].keys(): |
366 transition_infos["from"].append(step_name) |
401 transition_infos["from"].append(step_name) |