63 self.Name = name |
63 self.Name = name |
64 self.Type = type |
64 self.Type = type |
65 self.ReturnType = None |
65 self.ReturnType = None |
66 self.Interface = [] |
66 self.Interface = [] |
67 self.InitialSteps = [] |
67 self.InitialSteps = [] |
68 self.BlockComputed = {} |
68 self.ComputedBlocks = {} |
69 self.ComputedBlocks = "" |
69 self.ComputedConnectors = {} |
70 self.SFCNetworks = {"Steps":{}, "Transitions":{}, "Actions":{}} |
70 self.SFCNetworks = {"Steps":{}, "Transitions":{}, "Actions":{}} |
|
71 self.SFCComputedBlocks = "" |
71 self.ActionNumber = 0 |
72 self.ActionNumber = 0 |
72 self.Program = "" |
73 self.Program = "" |
73 |
74 |
74 def GetActionNumber(self): |
75 def GetActionNumber(self): |
75 self.ActionNumber += 1 |
76 self.ActionNumber += 1 |
111 body_type = body_content["name"] |
112 body_type = body_content["name"] |
112 if body_type in ["IL","ST"]: |
113 if body_type in ["IL","ST"]: |
113 self.Program = ReIndentText(body_content["value"].getText(), 2) |
114 self.Program = ReIndentText(body_content["value"].getText(), 2) |
114 elif body_type == "FBD": |
115 elif body_type == "FBD": |
115 for instance in body.getContentInstances(): |
116 for instance in body.getContentInstances(): |
116 if isinstance(instance, plcopen.outVariable): |
117 if isinstance(instance, (plcopen.outVariable, plcopen.inOutVariable)): |
117 var = instance.getExpression() |
118 var = instance.getExpression() |
118 connections = instance.connectionPointIn.getConnections() |
119 connections = instance.connectionPointIn.getConnections() |
119 if connections and len(connections) == 1: |
120 if connections and len(connections) == 1: |
120 expression = self.ComputeFBDExpression(body, connections[0]) |
121 expression = self.ComputeFBDExpression(body, connections[0]) |
121 self.Program += " %s := %s;\n"%(var, expression) |
122 self.Program += " %s := %s;\n"%(var, expression) |
|
123 if isinstance(instance, plcopen.connector): |
|
124 connector = instance.getName() |
|
125 if self.ComputedConnectors.get(connector, None): |
|
126 continue |
|
127 connections = instance.connectionPointIn.getConnections() |
|
128 if connections and len(connections) == 1: |
|
129 self.ComputedConnectors[connector] = self.ComputeFBDExpression(body, connections[0]) |
122 elif body_type == "LD": |
130 elif body_type == "LD": |
123 for instance in body.getContentInstances(): |
131 for instance in body.getContentInstances(): |
124 if isinstance(instance, plcopen.coil): |
132 if isinstance(instance, plcopen.coil): |
125 paths = self.GenerateLDPaths(instance.connectionPointIn.getConnections(), body) |
133 paths = self.GenerateLDPaths(instance.connectionPointIn.getConnections(), body) |
126 variable = self.ExtractModifier(instance, instance.getVariable()) |
134 variable = self.ExtractModifier(instance, instance.getVariable()) |
134 self.GenerateSFCStepActions(instance, pou) |
142 self.GenerateSFCStepActions(instance, pou) |
135 elif isinstance(instance, plcopen.transition): |
143 elif isinstance(instance, plcopen.transition): |
136 self.GenerateSFCTransition(instance, pou) |
144 self.GenerateSFCTransition(instance, pou) |
137 elif isinstance(instance, plcopen.jumpStep): |
145 elif isinstance(instance, plcopen.jumpStep): |
138 self.GenerateSFCJump(instance, pou) |
146 self.GenerateSFCJump(instance, pou) |
139 if len(self.InitialSteps) > 0 and self.ComputedBlocks != "": |
147 if len(self.InitialSteps) > 0 and self.SFCComputedBlocks != "": |
140 action_name = "COMPUTE_FUNCTION_BLOCKS" |
148 action_name = "COMPUTE_FUNCTION_BLOCKS" |
141 action_infos = {"qualifier" : "S", "content" : action_name} |
149 action_infos = {"qualifier" : "S", "content" : action_name} |
142 self.SFCNetworks["Steps"][self.InitialSteps[0]]["actions"].append(action_infos) |
150 self.SFCNetworks["Steps"][self.InitialSteps[0]]["actions"].append(action_infos) |
143 self.SFCNetworks["Actions"][action_name] = ReIndentText(self.ComputedBlocks, 4) |
151 self.SFCNetworks["Actions"][action_name] = ReIndentText(self.SFCComputedBlocks, 4) |
144 self.Program = "" |
152 self.Program = "" |
145 else: |
153 else: |
146 raise Exception |
154 raise Exception |
147 for initialstep in self.InitialSteps: |
155 for initialstep in self.InitialSteps: |
148 self.ComputeSFCStep(initialstep) |
156 self.ComputeSFCStep(initialstep) |
149 |
157 |
150 def ComputeFBDExpression(self, body, link): |
158 def ComputeFBDExpression(self, body, link): |
151 localid = link.getRefLocalId() |
159 localid = link.getRefLocalId() |
152 instance = body.getContentInstance(localid) |
160 instance = body.getContentInstance(localid) |
153 if isinstance(instance, plcopen.inVariable): |
161 if isinstance(instance, (plcopen.inVariable, plcopen.inOutVariable)): |
154 return instance.getExpression() |
162 return instance.getExpression() |
155 elif isinstance(instance, plcopen.block): |
163 elif isinstance(instance, plcopen.block): |
156 name = instance.getInstanceName() |
164 name = instance.getInstanceName() |
157 type = instance.getTypeName() |
165 type = instance.getTypeName() |
158 block_infos = GetBlockType(type) |
166 block_infos = GetBlockType(type) |
165 value = self.ComputeFBDExpression(body, connections[0]) |
173 value = self.ComputeFBDExpression(body, connections[0]) |
166 vars.append(self.ExtractModifier(variable, value)) |
174 vars.append(self.ExtractModifier(variable, value)) |
167 variable = instance.outputVariables.getVariable()[0] |
175 variable = instance.outputVariables.getVariable()[0] |
168 return self.ExtractModifier(variable, "%s(%s)"%(type, ", ".join(vars))) |
176 return self.ExtractModifier(variable, "%s(%s)"%(type, ", ".join(vars))) |
169 elif block_infos["type"] == "functionBlock": |
177 elif block_infos["type"] == "functionBlock": |
170 if not self.BlockComputed.get(name, False): |
178 if not self.ComputedBlocks.get(name, False): |
171 vars = [] |
179 vars = [] |
172 for variable in instance.inputVariables.getVariable(): |
180 for variable in instance.inputVariables.getVariable(): |
173 connections = variable.connectionPointIn.getConnections() |
181 connections = variable.connectionPointIn.getConnections() |
174 if connections and len(connections) == 1: |
182 if connections and len(connections) == 1: |
175 parameter = variable.getFormalParameter() |
183 parameter = variable.getFormalParameter() |
176 value = self.ComputeFBDExpression(body, connections[0]) |
184 value = self.ComputeFBDExpression(body, connections[0]) |
177 vars.append(self.ExtractModifier(variable, "%s := %s"%(parameter, value))) |
185 vars.append(self.ExtractModifier(variable, "%s := %s"%(parameter, value))) |
178 self.Program += " %s(%s);\n"%(name, ", ".join(vars)) |
186 self.Program += " %s(%s);\n"%(name, ", ".join(vars)) |
179 self.BlockComputed[name] = True |
187 self.ComputedBlocks[name] = True |
180 connectionPoint = link.getPosition()[-1] |
188 connectionPoint = link.getPosition()[-1] |
181 for variable in instance.outputVariables.getVariable(): |
189 for variable in instance.outputVariables.getVariable(): |
182 blockPointx, blockPointy = variable.connectionPointOut.getRelPosition() |
190 blockPointx, blockPointy = variable.connectionPointOut.getRelPosition() |
183 if instance.getX() + blockPointx == connectionPoint.getX() and instance.getY() + blockPointy == connectionPoint.getY(): |
191 if instance.getX() + blockPointx == connectionPoint.getX() and instance.getY() + blockPointy == connectionPoint.getY(): |
184 return self.ExtractModifier(variable, "%s.%s"%(name, variable.getFormalParameter())) |
192 return self.ExtractModifier(variable, "%s.%s"%(name, variable.getFormalParameter())) |
185 raise ValueError, "No output variable found" |
193 raise ValueError, "No output variable found" |
|
194 elif isinstance(instance, plcopen.continuation): |
|
195 name = instance.getName() |
|
196 computed_value = self.ComputedConnectors.get(name, None) |
|
197 if computed_value != None: |
|
198 return computed_value |
|
199 for tmp_instance in body.getContentInstances(): |
|
200 if isinstance(tmp_instance, plcopen.connector): |
|
201 if tmp_instance.getName() == name: |
|
202 connections = tmp_instance.connectionPointIn.getConnections() |
|
203 if connections and len(connections) == 1: |
|
204 expression = self.ComputeFBDExpression(body, connections[0]) |
|
205 self.ComputedConnectors[name] = expression |
|
206 return expression |
|
207 raise ValueError, "No connector found" |
186 |
208 |
187 def GenerateLDPaths(self, connections, body): |
209 def GenerateLDPaths(self, connections, body): |
188 paths = [] |
210 paths = [] |
189 for connection in connections: |
211 for connection in connections: |
190 localId = connection.getRefLocalId() |
212 localId = connection.getRefLocalId() |
381 if isinstance(instance, plcopen.outVariable): |
403 if isinstance(instance, plcopen.outVariable): |
382 connections = instance.connectionPointIn.getConnections() |
404 connections = instance.connectionPointIn.getConnections() |
383 if connections and len(connections) == 1: |
405 if connections and len(connections) == 1: |
384 expression = self.ComputeFBDExpression(transitionBody, connections[0]) |
406 expression = self.ComputeFBDExpression(transitionBody, connections[0]) |
385 transition_infos["content"] = "\n := %s;\n"%expression |
407 transition_infos["content"] = "\n := %s;\n"%expression |
386 self.ComputedBlocks += self.Program |
408 self.SFCComputedBlocks += self.Program |
387 self.Program = "" |
409 self.Program = "" |
388 elif transitionType == "LD": |
410 elif transitionType == "LD": |
389 for instance in transitionBody.getContentInstances(): |
411 for instance in transitionBody.getContentInstances(): |
390 if isinstance(instance, plcopen.coil): |
412 if isinstance(instance, plcopen.coil): |
391 paths = self.GenerateLDPaths(instance.connectionPointIn.getConnections(), transitionBody) |
413 paths = self.GenerateLDPaths(instance.connectionPointIn.getConnections(), transitionBody) |
392 expression = self.ComputeLDExpression(paths, True) |
414 expression = self.ComputeLDExpression(paths, True) |
393 transition_infos["content"] = "\n := %s;\n"%expression |
415 transition_infos["content"] = "\n := %s;\n"%expression |
394 self.ComputedBlocks += self.Program |
416 self.SFCComputedBlocks += self.Program |
395 self.Program = "" |
417 self.Program = "" |
396 elif transitionValues["type"] == "connection": |
418 elif transitionValues["type"] == "connection": |
397 body = pou.getBody() |
419 body = pou.getBody() |
398 connections = transition.getConnections() |
420 connections = transition.getConnections() |
399 network_type = self.GetNetworkType(connections, body) |
421 network_type = self.GetNetworkType(connections, body) |
401 raise Exception |
423 raise Exception |
402 if len(connections) > 1 or network_type == "LD": |
424 if len(connections) > 1 or network_type == "LD": |
403 paths = self.GenerateLDPaths(connections, body) |
425 paths = self.GenerateLDPaths(connections, body) |
404 expression = self.ComputeLDExpression(paths, True) |
426 expression = self.ComputeLDExpression(paths, True) |
405 transition_infos["content"] = "\n := %s;\n"%expression |
427 transition_infos["content"] = "\n := %s;\n"%expression |
406 self.ComputedBlocks += self.Program |
428 self.SFCComputedBlocks += self.Program |
407 self.Program = "" |
429 self.Program = "" |
408 else: |
430 else: |
409 expression = self.ComputeFBDExpression(body, connections[0]) |
431 expression = self.ComputeFBDExpression(body, connections[0]) |
410 transition_infos["content"] = "\n := %s;\n"%expression |
432 transition_infos["content"] = "\n := %s;\n"%expression |
411 self.ComputedBlocks += self.Program |
433 self.SFCComputedBlocks += self.Program |
412 self.Program = "" |
434 self.Program = "" |
413 for step in steps: |
435 for step in steps: |
414 self.GenerateSFCStep(step, pou) |
436 self.GenerateSFCStep(step, pou) |
415 step_name = step.getName() |
437 step_name = step.getName() |
416 if step_name in self.SFCNetworks["Steps"].keys(): |
438 if step_name in self.SFCNetworks["Steps"].keys(): |