| author | lbessard |
| Tue, 22 Apr 2008 16:16:00 +0200 | |
| changeset 208 | c70aefcadf66 |
| parent 200 | 8a1ed1959c69 |
| child 225 | 7726c8ffda42 |
| permissions | -rw-r--r-- |
| 0 | 1 |
#!/usr/bin/env python |
2 |
# -*- coding: utf-8 -*- |
|
3 |
||
4 |
#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor |
|
5 |
#based on the plcopen standard. |
|
6 |
# |
|
| 58 | 7 |
#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD |
| 0 | 8 |
# |
9 |
#See COPYING file for copyrights details. |
|
10 |
# |
|
11 |
#This library is free software; you can redistribute it and/or |
|
| 2 | 12 |
#modify it under the terms of the GNU General Public |
| 0 | 13 |
#License as published by the Free Software Foundation; either |
14 |
#version 2.1 of the License, or (at your option) any later version. |
|
15 |
# |
|
16 |
#This library is distributed in the hope that it will be useful, |
|
17 |
#but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
18 |
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
| 58 | 19 |
#General Public License for more details. |
| 0 | 20 |
# |
| 2 | 21 |
#You should have received a copy of the GNU General Public |
| 0 | 22 |
#License along with this library; if not, write to the Free Software |
23 |
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
24 |
||
| 2 | 25 |
from xmlclass import * |
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
26 |
from types import * |
| 166 | 27 |
import os, re |
| 0 | 28 |
|
29 |
""" |
|
30 |
Dictionary that makes the relation between var names in plcopen and displayed values |
|
31 |
""" |
|
32 |
VarTypes = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars",
|
|
33 |
"Output" : "outputVars", "InOut" : "inOutVars", "External" : "externalVars", |
|
34 |
"Global" : "globalVars", "Access" : "accessVars"} |
|
35 |
||
36 |
""" |
|
37 |
Define in which order var types must be displayed |
|
38 |
""" |
|
39 |
VarOrder = ["Local","Temp","Input","Output","InOut","External","Global","Access"] |
|
40 |
||
41 |
""" |
|
42 |
Define which action qualifier must be associated with a duration |
|
43 |
""" |
|
44 |
QualifierList = {"N" : False, "R" : False, "S" : False, "L" : True, "D" : True,
|
|
45 |
"P" : False, "P0" : False, "P1" : False, "SD" : True, "DS" : True, "SL" : True} |
|
46 |
||
| 151 | 47 |
PLCOpenClasses = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd")) |
| 2 | 48 |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
49 |
cls = PLCOpenClasses.get("formattedText", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
50 |
if cls: |
| 58 | 51 |
def updateElementName(self, old_name, new_name): |
52 |
index = self.text.find(old_name) |
|
53 |
while index != -1: |
|
54 |
if index > 0 and (self.text[index - 1].isalnum() or self.text[index - 1] == "_"): |
|
55 |
index = self.text.find(old_name, index + len(old_name)) |
|
56 |
elif index < len(self.text) - len(old_name) and (self.text[index + len(old_name)].isalnum() or self.text[index + len(old_name)] == "_"): |
|
57 |
index = self.text.find(old_name, index + len(old_name)) |
|
58 |
else: |
|
59 |
self.text = self.text[:index] + new_name + self.text[index + len(old_name):] |
|
60 |
index = self.text.find(old_name, index + len(new_name)) |
|
61 |
setattr(cls, "updateElementName", updateElementName) |
|
62 |
||
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
63 |
cls = PLCOpenClasses.get("project", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
64 |
if cls: |
| 2 | 65 |
cls.singleLineAttributes = False |
66 |
||
| 151 | 67 |
def setname(self, name): |
68 |
self.contentHeader.setname(name) |
|
69 |
setattr(cls, "setname", setname) |
|
| 145 | 70 |
|
| 151 | 71 |
def getname(self): |
72 |
return self.contentHeader.getname() |
|
73 |
setattr(cls, "getname", getname) |
|
74 |
||
75 |
def getfileHeader(self): |
|
| 2 | 76 |
fileheader = {}
|
| 151 | 77 |
fileheader["companyName"] = self.fileHeader.getcompanyName() |
78 |
if self.fileHeader.getcompanyURL(): |
|
79 |
fileheader["companyURL"] = self.fileHeader.getcompanyURL() |
|
80 |
fileheader["productName"] = self.fileHeader.getproductName() |
|
81 |
fileheader["productVersion"] = self.fileHeader.getproductVersion() |
|
82 |
if self.fileHeader.getproductRelease(): |
|
83 |
fileheader["productRelease"] = self.fileHeader.getproductRelease() |
|
84 |
fileheader["creationDateTime"] = self.fileHeader.getcreationDateTime() |
|
85 |
if self.fileHeader.getcontentDescription(): |
|
86 |
fileheader["contentDescription"] = self.fileHeader.getcontentDescription() |
|
| 2 | 87 |
return fileheader |
| 151 | 88 |
setattr(cls, "getfileHeader", getfileHeader) |
89 |
||
90 |
def setfileHeader(self, fileheader): |
|
91 |
self.fileHeader.setcompanyName(fileheader["companyName"]) |
|
| 2 | 92 |
if "companyURL" in fileheader: |
| 151 | 93 |
self.fileHeader.setcompanyURL(fileheader["companyURL"]) |
94 |
self.fileHeader.setproductName(fileheader["productName"]) |
|
95 |
self.fileHeader.setproductVersion(fileheader["productVersion"]) |
|
| 2 | 96 |
if "productRelease" in fileheader: |
| 151 | 97 |
self.fileHeader.setproductRelease(fileheader["productRelease"]) |
98 |
self.fileHeader.setcreationDateTime(fileheader["creationDateTime"]) |
|
| 2 | 99 |
if "contentDescription" in fileheader: |
| 151 | 100 |
self.fileHeader.setcontentDescription(fileheader["contentDescription"]) |
101 |
setattr(cls, "setfileHeader", setfileHeader) |
|
102 |
||
103 |
def getcontentHeader(self): |
|
| 145 | 104 |
contentheader = {}
|
| 151 | 105 |
contentheader["projectName"] = self.contentHeader.getname() |
106 |
if self.contentHeader.getversion(): |
|
107 |
contentheader["projectVersion"] = self.contentHeader.getversion() |
|
108 |
if self.contentHeader.getmodificationDateTime(): |
|
109 |
contentheader["modificationDateTime"] = self.contentHeader.getmodificationDateTime() |
|
110 |
if self.contentHeader.getorganization(): |
|
111 |
contentheader["organization"] = self.contentHeader.getorganization() |
|
112 |
if self.contentHeader.getauthor(): |
|
113 |
contentheader["authorName"] = self.contentHeader.getauthor() |
|
114 |
if self.contentHeader.getlanguage(): |
|
115 |
contentheader["language"] = self.contentHeader.getlanguage() |
|
116 |
contentheader["pageSize"] = self.contentHeader.getpageSize() |
|
117 |
contentheader["scaling"] = self.contentHeader.getscaling() |
|
| 145 | 118 |
return contentheader |
| 151 | 119 |
setattr(cls, "getcontentHeader", getcontentHeader) |
120 |
||
121 |
def setcontentHeader(self, contentheader): |
|
122 |
self.contentHeader.setname(contentheader["projectName"]) |
|
| 145 | 123 |
if "projectVersion" in contentheader: |
| 151 | 124 |
self.contentHeader.setversion(contentheader["projectVersion"]) |
| 145 | 125 |
if "modificationDateTime" in contentheader: |
| 151 | 126 |
self.contentHeader.setmodificationDateTime(contentheader["modificationDateTime"]) |
| 145 | 127 |
if "organization" in contentheader: |
| 151 | 128 |
self.contentHeader.setorganization(contentheader["organization"]) |
| 145 | 129 |
if "authorName" in contentheader: |
| 151 | 130 |
self.contentHeader.setauthor(contentheader["authorName"]) |
| 145 | 131 |
if "language" in contentheader: |
| 151 | 132 |
self.contentHeader.setlanguage(contentheader["language"]) |
133 |
self.contentHeader.setpageSize(*contentheader["pageSize"]) |
|
134 |
self.contentHeader.setscaling(contentheader["scaling"]) |
|
135 |
setattr(cls, "setcontentHeader", setcontentHeader) |
|
136 |
||
137 |
def getdataTypes(self): |
|
138 |
return self.types.getdataTypeElements() |
|
139 |
setattr(cls, "getdataTypes", getdataTypes) |
|
140 |
||
141 |
def getdataType(self, name): |
|
142 |
return self.types.getdataTypeElement(name) |
|
143 |
setattr(cls, "getdataType", getdataType) |
|
144 |
||
145 |
def appenddataType(self, name): |
|
146 |
self.types.appenddataTypeElement(name) |
|
147 |
setattr(cls, "appenddataType", appenddataType) |
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
148 |
|
| 151 | 149 |
def insertdataType(self, index, datatype): |
150 |
self.types.insertdataTypeElement(index, datatype) |
|
151 |
setattr(cls, "insertdataType", insertdataType) |
|
152 |
||
153 |
def removedataType(self, name): |
|
154 |
self.types.removedataTypeElement(name) |
|
155 |
setattr(cls, "removedataType", removedataType) |
|
156 |
||
157 |
def getpous(self): |
|
158 |
return self.types.getpouElements() |
|
159 |
setattr(cls, "getpous", getpous) |
|
160 |
||
161 |
def getpou(self, name): |
|
162 |
return self.types.getpouElement(name) |
|
163 |
setattr(cls, "getpou", getpou) |
|
164 |
||
165 |
def appendpou(self, name, pou_type, body_type): |
|
166 |
self.types.appendpouElement(name, pou_type, body_type) |
|
167 |
setattr(cls, "appendpou", appendpou) |
|
| 0 | 168 |
|
| 151 | 169 |
def insertpou(self, index, pou): |
170 |
self.types.insertpouElement(index, pou) |
|
171 |
setattr(cls, "insertpou", insertpou) |
|
172 |
||
173 |
def removepou(self, name): |
|
174 |
self.types.removepouElement(name) |
|
175 |
setattr(cls, "removepou", removepou) |
|
176 |
||
177 |
def getconfigurations(self): |
|
178 |
configurations = self.instances.configurations.getconfiguration() |
|
| 2 | 179 |
if configurations: |
180 |
return configurations |
|
181 |
return [] |
|
| 151 | 182 |
setattr(cls, "getconfigurations", getconfigurations) |
183 |
||
184 |
def getconfiguration(self, name): |
|
185 |
for configuration in self.instances.configurations.getconfiguration(): |
|
186 |
if configuration.getname() == name: |
|
| 2 | 187 |
return configuration |
188 |
return None |
|
| 151 | 189 |
setattr(cls, "getconfiguration", getconfiguration) |
190 |
||
191 |
def addconfiguration(self, name): |
|
192 |
for configuration in self.instances.configurations.getconfiguration(): |
|
193 |
if configuration.getname() == name: |
|
| 2 | 194 |
raise ValueError, "\"%s\" configuration already exists !!!"%name |
195 |
new_configuration = PLCOpenClasses["configurations_configuration"]() |
|
| 151 | 196 |
new_configuration.setname(name) |
197 |
self.instances.configurations.appendconfiguration(new_configuration) |
|
198 |
setattr(cls, "addconfiguration", addconfiguration) |
|
199 |
||
200 |
def removeconfiguration(self, name): |
|
| 2 | 201 |
found = False |
| 151 | 202 |
for idx, configuration in enumerate(self.instances.configurations.getconfiguration()): |
203 |
if configuration.getname() == name: |
|
204 |
self.instances.configurations.removeconfiguration(idx) |
|
| 2 | 205 |
found = True |
206 |
break |
|
207 |
if not found: |
|
208 |
raise ValueError, "\"%s\" configuration doesn't exist !!!"%name |
|
| 151 | 209 |
setattr(cls, "removeconfiguration", removeconfiguration) |
210 |
||
211 |
def getconfigurationResource(self, config_name, name): |
|
212 |
configuration = self.getconfiguration(config_name) |
|
| 2 | 213 |
if configuration: |
| 151 | 214 |
for resource in configuration.getresource(): |
215 |
if resource.getname() == name: |
|
| 2 | 216 |
return resource |
217 |
return None |
|
| 151 | 218 |
setattr(cls, "getconfigurationResource", getconfigurationResource) |
219 |
||
220 |
def addconfigurationResource(self, config_name, name): |
|
221 |
configuration = self.getconfiguration(config_name) |
|
| 2 | 222 |
if configuration: |
| 151 | 223 |
for resource in configuration.getresource(): |
224 |
if resource.getname() == name: |
|
| 2 | 225 |
raise ValueError, "\"%s\" resource already exists in \"%s\" configuration !!!"%(name, config_name) |
226 |
new_resource = PLCOpenClasses["configuration_resource"]() |
|
| 151 | 227 |
new_resource.setname(name) |
228 |
configuration.appendresource(new_resource) |
|
229 |
setattr(cls, "addconfigurationResource", addconfigurationResource) |
|
230 |
||
231 |
def removeconfigurationResource(self, config_name, name): |
|
232 |
configuration = self.getconfiguration(config_name) |
|
| 2 | 233 |
if configuration: |
| 0 | 234 |
found = False |
| 151 | 235 |
for idx, resource in enumerate(configuration.getresource()): |
236 |
if resource.getname() == name: |
|
237 |
configuration.removeresource(idx) |
|
| 0 | 238 |
found = True |
239 |
break |
|
240 |
if not found: |
|
| 2 | 241 |
raise ValueError, "\"%s\" resource doesn't exist in \"%s\" configuration !!!"%(name, config_name) |
| 151 | 242 |
setattr(cls, "removeconfigurationResource", removeconfigurationResource) |
243 |
||
244 |
def updateElementName(self, old_name, new_name): |
|
245 |
for pou in self.types.getpouElements(): |
|
| 58 | 246 |
pou.updateElementName(old_name, new_name) |
| 151 | 247 |
for configuration in self.instances.configurations.getconfiguration(): |
| 58 | 248 |
configuration.updateElementName(old_name, new_name) |
249 |
setattr(cls, "updateElementName", updateElementName) |
|
250 |
||
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
251 |
cls = PLCOpenClasses.get("project_fileHeader", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
252 |
if cls: |
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
253 |
cls.singleLineAttributes = False |
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
254 |
|
| 145 | 255 |
cls = PLCOpenClasses.get("project_contentHeader", None)
|
256 |
if cls: |
|
257 |
cls.singleLineAttributes = False |
|
258 |
||
| 151 | 259 |
def setpageSize(self, width, height): |
260 |
self.coordinateInfo.setpageSize(width, height) |
|
261 |
setattr(cls, "setpageSize", setpageSize) |
|
262 |
||
263 |
def getpageSize(self): |
|
264 |
return self.coordinateInfo.getpageSize() |
|
265 |
setattr(cls, "getpageSize", getpageSize) |
|
266 |
||
267 |
def setscaling(self, scaling): |
|
| 145 | 268 |
for language, (x, y) in scaling.items(): |
| 151 | 269 |
self.coordinateInfo.setscaling(language, x, y) |
270 |
setattr(cls, "setscaling", setscaling) |
|
271 |
||
272 |
def getscaling(self): |
|
| 145 | 273 |
scaling = {}
|
| 151 | 274 |
scaling["FBD"] = self.coordinateInfo.getscaling("FBD")
|
275 |
scaling["LD"] = self.coordinateInfo.getscaling("LD")
|
|
276 |
scaling["SFC"] = self.coordinateInfo.getscaling("SFC")
|
|
| 145 | 277 |
return scaling |
| 151 | 278 |
setattr(cls, "getscaling", getscaling) |
| 145 | 279 |
|
280 |
cls = PLCOpenClasses.get("contentHeader_coordinateInfo", None)
|
|
281 |
if cls: |
|
| 151 | 282 |
def setpageSize(self, width, height): |
| 145 | 283 |
if width == 0 and height == 0: |
| 151 | 284 |
self.deletepageSize() |
| 145 | 285 |
else: |
286 |
if self.pageSize is None: |
|
| 151 | 287 |
self.addpageSize() |
288 |
self.pageSize.setx(width) |
|
289 |
self.pageSize.sety(height) |
|
290 |
setattr(cls, "setpageSize", setpageSize) |
|
291 |
||
292 |
def getpageSize(self): |
|
| 145 | 293 |
if self.pageSize is not None: |
| 151 | 294 |
return self.pageSize.getx(), self.pageSize.gety() |
| 145 | 295 |
return 0, 0 |
| 151 | 296 |
setattr(cls, "getpageSize", getpageSize) |
297 |
||
298 |
def setscaling(self, language, x, y): |
|
| 145 | 299 |
if language == "FBD": |
| 151 | 300 |
self.fbd.scaling.setx(x) |
301 |
self.fbd.scaling.sety(y) |
|
| 145 | 302 |
elif language == "LD": |
| 151 | 303 |
self.ld.scaling.setx(x) |
304 |
self.ld.scaling.sety(y) |
|
| 145 | 305 |
elif language == "SFC": |
| 151 | 306 |
self.sfc.scaling.setx(x) |
307 |
self.sfc.scaling.sety(y) |
|
308 |
setattr(cls, "setscaling", setscaling) |
|
309 |
||
310 |
def getscaling(self, language): |
|
| 145 | 311 |
if language == "FBD": |
| 151 | 312 |
return self.fbd.scaling.getx(), self.fbd.scaling.gety() |
| 145 | 313 |
elif language == "LD": |
| 151 | 314 |
return self.ld.scaling.getx(), self.ld.scaling.gety() |
| 145 | 315 |
elif language == "SFC": |
| 151 | 316 |
return self.sfc.scaling.getx(), self.sfc.scaling.gety() |
| 145 | 317 |
return 0, 0 |
| 151 | 318 |
setattr(cls, "getscaling", getscaling) |
| 145 | 319 |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
320 |
cls = PLCOpenClasses.get("configurations_configuration", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
321 |
if cls: |
| 58 | 322 |
def updateElementName(self, old_name, new_name): |
| 151 | 323 |
for resource in self.getresource(): |
| 58 | 324 |
resource.updateElementName(old_name, new_name) |
325 |
setattr(cls, "updateElementName", updateElementName) |
|
326 |
||
327 |
||
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
328 |
cls = PLCOpenClasses.get("configuration_resource", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
329 |
if cls: |
| 58 | 330 |
def updateElementName(self, old_name, new_name): |
| 187 | 331 |
for instance in self.getpouInstance(): |
| 58 | 332 |
instance.updateElementName(old_name, new_name) |
| 187 | 333 |
for task in self.gettask(): |
| 58 | 334 |
task.updateElementName(old_name, new_name) |
335 |
setattr(cls, "updateElementName", updateElementName) |
|
336 |
||
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
337 |
cls = PLCOpenClasses.get("resource_task", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
338 |
if cls: |
| 58 | 339 |
def updateElementName(self, old_name, new_name): |
340 |
if self.single == old_name: |
|
341 |
self.single = new_name |
|
| 187 | 342 |
for instance in self.getpouInstance(): |
| 58 | 343 |
instance.updateElementName(old_name, new_name) |
344 |
setattr(cls, "updateElementName", updateElementName) |
|
345 |
||
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
346 |
cls = PLCOpenClasses.get("pouInstance", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
347 |
if cls: |
| 58 | 348 |
def updateElementName(self, old_name, new_name): |
349 |
if self.type == old_name: |
|
350 |
self.type = new_name |
|
351 |
setattr(cls, "updateElementName", updateElementName) |
|
352 |
||
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
353 |
cls = PLCOpenClasses.get("project_types", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
354 |
if cls: |
| 151 | 355 |
def getdataTypeElements(self): |
356 |
return self.dataTypes.getdataType() |
|
357 |
setattr(cls, "getdataTypeElements", getdataTypeElements) |
|
358 |
||
359 |
def getdataTypeElement(self, name): |
|
360 |
elements = self.dataTypes.getdataType() |
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
361 |
for element in elements: |
| 151 | 362 |
if element.getname() == name: |
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
363 |
return element |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
364 |
return None |
| 151 | 365 |
setattr(cls, "getdataTypeElement", getdataTypeElement) |
366 |
||
367 |
def appenddataTypeElement(self, name): |
|
368 |
for element in self.dataTypes.getdataType(): |
|
369 |
if element.getname() == name: |
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
370 |
raise ValueError, "\"%s\" Data Type already exists !!!"%name |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
371 |
new_datatype = PLCOpenClasses["dataTypes_dataType"]() |
| 151 | 372 |
new_datatype.setname(name) |
373 |
new_datatype.baseType.setcontent({"name" : "BOOL", "value" : None})
|
|
374 |
self.dataTypes.appenddataType(new_datatype) |
|
375 |
setattr(cls, "appenddataTypeElement", appenddataTypeElement) |
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
376 |
|
| 151 | 377 |
def insertdataTypeElement(self, index, dataType): |
378 |
self.dataTypes.insertdataType(index, dataType) |
|
379 |
setattr(cls, "insertdataTypeElement", insertdataTypeElement) |
|
380 |
||
381 |
def removedataTypeElement(self, name): |
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
382 |
found = False |
| 151 | 383 |
for idx, element in enumerate(self.dataTypes.getdataType()): |
384 |
if element.getname() == name: |
|
385 |
self.dataTypes.removedataType(idx) |
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
386 |
found = True |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
387 |
break |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
388 |
if not found: |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
389 |
raise ValueError, "\"%s\" Data Type doesn't exist !!!"%name |
| 151 | 390 |
setattr(cls, "removedataTypeElement", removedataTypeElement) |
391 |
||
392 |
def getpouElements(self): |
|
393 |
return self.pous.getpou() |
|
394 |
setattr(cls, "getpouElements", getpouElements) |
|
395 |
||
396 |
def getpouElement(self, name): |
|
397 |
elements = self.pous.getpou() |
|
| 2 | 398 |
for element in elements: |
| 151 | 399 |
if element.getname() == name: |
| 2 | 400 |
return element |
401 |
return None |
|
| 151 | 402 |
setattr(cls, "getpouElement", getpouElement) |
403 |
||
404 |
def appendpouElement(self, name, pou_type, body_type): |
|
405 |
for element in self.pous.getpou(): |
|
406 |
if element.getname() == name: |
|
| 2 | 407 |
raise ValueError, "\"%s\" POU already exists !!!"%name |
408 |
new_pou = PLCOpenClasses["pous_pou"]() |
|
| 151 | 409 |
new_pou.setname(name) |
410 |
new_pou.setpouType(pou_type) |
|
411 |
new_pou.setbody(PLCOpenClasses["body"]()) |
|
412 |
new_pou.setbodyType(body_type) |
|
413 |
self.pous.appendpou(new_pou) |
|
414 |
setattr(cls, "appendpouElement", appendpouElement) |
|
| 2 | 415 |
|
| 151 | 416 |
def insertpouElement(self, index, pou): |
417 |
self.pous.insertpou(index, pou) |
|
418 |
setattr(cls, "insertpouElement", insertpouElement) |
|
419 |
||
420 |
def removepouElement(self, name): |
|
| 2 | 421 |
found = False |
| 151 | 422 |
for idx, element in enumerate(self.pous.getpou()): |
423 |
if element.getname() == name: |
|
424 |
self.pous.removepou(idx) |
|
| 2 | 425 |
found = True |
426 |
break |
|
427 |
if not found: |
|
428 |
raise ValueError, "\"%s\" POU doesn't exist !!!"%name |
|
| 151 | 429 |
setattr(cls, "removepouElement", removepouElement) |
430 |
||
431 |
def setbodyType(self, type): |
|
| 2 | 432 |
if type == "IL": |
| 151 | 433 |
self.body.setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})
|
| 2 | 434 |
elif type == "ST": |
| 151 | 435 |
self.body.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
|
| 2 | 436 |
elif type == "LD": |
| 151 | 437 |
self.body.setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})
|
| 2 | 438 |
elif type == "FBD": |
| 151 | 439 |
self.body.setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})
|
| 2 | 440 |
elif type == "SFC": |
| 151 | 441 |
self.body.setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})
|
| 2 | 442 |
else: |
443 |
raise ValueError, "%s isn't a valid body type!"%type |
|
444 |
||
| 151 | 445 |
def getbodyType(self): |
446 |
return self.body.getcontent()["name"] |
|
447 |
||
448 |
def resetexecutionOrder(self): |
|
449 |
self.body.resetexecutionOrder() |
|
450 |
||
451 |
def compileexecutionOrder(self): |
|
452 |
self.body.compileexecutionOrder() |
|
453 |
||
454 |
def setelementExecutionOrder(self, instance, new_executionOrder): |
|
455 |
self.body.setelementExecutionOrder(instance, new_executionOrder) |
|
456 |
||
457 |
def addinstance(self, name, instance): |
|
458 |
self.body.appendcontentInstance(name, instance) |
|
459 |
||
460 |
def getinstances(self): |
|
461 |
return self.body.getcontentInstances() |
|
462 |
||
463 |
def getinstance(self, id): |
|
464 |
return self.body.getcontentInstance(id) |
|
465 |
||
466 |
def getrandomInstance(self, exclude): |
|
467 |
return self.body.getcontentRandomInstance(exclude) |
|
468 |
||
469 |
def getinstanceByName(self, name): |
|
470 |
return self.body.getcontentInstanceByName(name) |
|
471 |
||
472 |
def removeinstance(self, id): |
|
473 |
self.body.removecontentInstance(id) |
|
474 |
||
475 |
def settext(self, text): |
|
476 |
self.body.settext(text) |
|
477 |
||
478 |
def gettext(self): |
|
479 |
return self.body.gettext() |
|
480 |
setattr(cls, "gettext", gettext) |
|
| 2 | 481 |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
482 |
cls = PLCOpenClasses.get("pous_pou", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
483 |
if cls: |
| 151 | 484 |
setattr(cls, "setbodyType", setbodyType) |
485 |
setattr(cls, "getbodyType", getbodyType) |
|
486 |
setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
|
487 |
setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
|
488 |
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) |
|
489 |
setattr(cls, "addinstance", addinstance) |
|
490 |
setattr(cls, "getinstances", getinstances) |
|
491 |
setattr(cls, "getinstance", getinstance) |
|
492 |
setattr(cls, "getrandomInstance", getrandomInstance) |
|
493 |
setattr(cls, "getinstanceByName", getinstanceByName) |
|
494 |
setattr(cls, "removeinstance", removeinstance) |
|
495 |
setattr(cls, "settext", settext) |
|
496 |
setattr(cls, "gettext", gettext) |
|
497 |
||
498 |
def getvars(self): |
|
| 2 | 499 |
vars = [] |
500 |
reverse_types = {}
|
|
501 |
for name, value in VarTypes.items(): |
|
502 |
reverse_types[value] = name |
|
| 151 | 503 |
for varlist in self.interface.getcontent(): |
| 2 | 504 |
vars.append((reverse_types[varlist["name"]], varlist["value"])) |
505 |
return vars |
|
| 151 | 506 |
setattr(cls, "getvars", getvars) |
507 |
||
508 |
def setvars(self, vars): |
|
509 |
self.interface.setcontent([]) |
|
| 2 | 510 |
for vartype, varlist in vars: |
| 151 | 511 |
self.interface.appendcontent({"name" : VarTypes[vartype], "value" : varlist})
|
512 |
setattr(cls, "setvars", setvars) |
|
513 |
||
514 |
def addpouVar(self, type, name): |
|
515 |
content = self.interface.getcontent() |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
516 |
if len(content) == 0 or content[-1]["name"] != "localVars": |
| 151 | 517 |
content.append({"name" : "localVars", "value" : PLCOpenClasses["interface_localVars"]()})
|
|
68
66308e07402c
Adding support for allowing declarations of function block into POU interface
lbessard
parents:
67
diff
changeset
|
518 |
else: |
|
66308e07402c
Adding support for allowing declarations of function block into POU interface
lbessard
parents:
67
diff
changeset
|
519 |
varlist = content[-1]["value"] |
| 151 | 520 |
variables = varlist.getvariable() |
521 |
if varlist.getconstant() or varlist.getretain() or len(variables) > 0 and variables[0].getaddress(): |
|
522 |
content.append({"name" : "localVars", "value" : PLCOpenClasses["interface_localVars"]()})
|
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
523 |
var = PLCOpenClasses["varListPlain_variable"]() |
| 151 | 524 |
var.setname(name) |
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
525 |
var_type = PLCOpenClasses["dataType"]() |
| 151 | 526 |
derived_type = PLCOpenClasses["derivedTypes_derived"]() |
527 |
derived_type.setname(type) |
|
528 |
var_type.setcontent({"name" : "derived", "value" : derived_type})
|
|
529 |
var.settype(var_type) |
|
530 |
content[-1]["value"].appendvariable(var) |
|
531 |
setattr(cls, "addpouVar", addpouVar) |
|
532 |
||
533 |
def changepouVar(self, old_type, old_name, new_type, new_name): |
|
534 |
content = self.interface.getcontent() |
|
| 94 | 535 |
for varlist in content: |
| 151 | 536 |
variables = varlist["value"].getvariable() |
| 94 | 537 |
for var in variables: |
| 151 | 538 |
if var.getname() == old_name: |
539 |
vartype_content = var.gettype().getcontent() |
|
540 |
if vartype_content["name"] == "derived" and vartype_content["value"].getname() == old_type: |
|
541 |
var.setname(new_name) |
|
542 |
vartype_content["value"].setname(new_type) |
|
| 94 | 543 |
return |
| 151 | 544 |
setattr(cls, "changepouVar", changepouVar) |
545 |
||
546 |
def removepouVar(self, type, name): |
|
547 |
content = self.interface.getcontent() |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
548 |
for varlist in content: |
| 151 | 549 |
variables = varlist["value"].getvariable() |
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
550 |
for var in variables: |
| 151 | 551 |
if var.getname() == name: |
552 |
vartype_content = var.gettype().getcontent() |
|
553 |
if vartype_content["name"] == "derived" and vartype_content["value"].getname() == type: |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
554 |
variables.remove(var) |
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
555 |
break |
| 151 | 556 |
if len(varlist["value"].getvariable()) == 0: |
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
557 |
content.remove(varlist) |
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
558 |
break |
| 151 | 559 |
setattr(cls, "removepouVar", removepouVar) |
560 |
||
561 |
def hasblock(self, name): |
|
562 |
if self.getbodyType() in ["FBD", "LD", "SFC"]: |
|
563 |
for instance in self.getinstances(): |
|
564 |
if isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and instance.getinstanceName() == name: |
|
|
68
66308e07402c
Adding support for allowing declarations of function block into POU interface
lbessard
parents:
67
diff
changeset
|
565 |
return True |
| 89 | 566 |
if self.transitions: |
| 151 | 567 |
for transition in self.transitions.gettransition(): |
568 |
result = transition.hasblock(name) |
|
| 89 | 569 |
if result: |
570 |
return result |
|
571 |
if self.actions: |
|
| 151 | 572 |
for action in self.actions.getaction(): |
573 |
result = action.hasblock(name) |
|
| 89 | 574 |
if result: |
575 |
return result |
|
|
68
66308e07402c
Adding support for allowing declarations of function block into POU interface
lbessard
parents:
67
diff
changeset
|
576 |
return False |
| 151 | 577 |
setattr(cls, "hasblock", hasblock) |
578 |
||
579 |
def addtransition(self, name, type): |
|
| 2 | 580 |
if not self.transitions: |
| 151 | 581 |
self.addtransitions() |
582 |
self.transitions.settransition([]) |
|
| 2 | 583 |
transition = PLCOpenClasses["transitions_transition"]() |
| 151 | 584 |
transition.setname(name) |
585 |
transition.setbodyType(type) |
|
| 200 | 586 |
if type == "ST": |
587 |
transition.settext(":= ;")
|
|
588 |
elif type == "IL": |
|
589 |
transition.settext("\tST\t%s"%name)
|
|
| 151 | 590 |
self.transitions.appendtransition(transition) |
591 |
setattr(cls, "addtransition", addtransition) |
|
592 |
||
593 |
def gettransition(self, name): |
|
| 2 | 594 |
if self.transitions: |
| 151 | 595 |
for transition in self.transitions.gettransition(): |
596 |
if transition.getname() == name: |
|
| 2 | 597 |
return transition |
598 |
return None |
|
| 151 | 599 |
setattr(cls, "gettransition", gettransition) |
| 2 | 600 |
|
| 151 | 601 |
def gettransitionList(self): |
| 2 | 602 |
if self.transitions: |
| 151 | 603 |
return self.transitions.gettransition() |
| 2 | 604 |
return [] |
| 151 | 605 |
setattr(cls, "gettransitionList", gettransitionList) |
606 |
||
607 |
def removetransition(self, name): |
|
| 2 | 608 |
if self.transitions: |
| 151 | 609 |
transitions = self.transitions.gettransition() |
| 2 | 610 |
i = 0 |
611 |
removed = False |
|
612 |
while i < len(transitions) and not removed: |
|
| 151 | 613 |
if transitions[i].getname() == name: |
| 46 | 614 |
transitions.pop(i) |
| 2 | 615 |
removed = True |
616 |
i += 1 |
|
617 |
if not removed: |
|
618 |
raise ValueError, "Transition with name %s doesn't exists!"%name |
|
| 151 | 619 |
setattr(cls, "removetransition", removetransition) |
620 |
||
621 |
def addaction(self, name, type): |
|
| 2 | 622 |
if not self.actions: |
| 151 | 623 |
self.addactions() |
624 |
self.actions.setaction([]) |
|
| 2 | 625 |
action = PLCOpenClasses["actions_action"]() |
| 151 | 626 |
action.setname(name) |
627 |
action.setbodyType(type) |
|
628 |
self.actions.appendaction(action) |
|
629 |
setattr(cls, "addaction", addaction) |
|
630 |
||
631 |
def getaction(self, name): |
|
| 2 | 632 |
if self.actions: |
| 151 | 633 |
for action in self.actions.getaction(): |
634 |
if action.getname() == name: |
|
| 2 | 635 |
return action |
636 |
return None |
|
| 151 | 637 |
setattr(cls, "getaction", getaction) |
638 |
||
639 |
def getactionList(self): |
|
| 2 | 640 |
if self.actions: |
| 151 | 641 |
return self.actions.getaction() |
| 2 | 642 |
return [] |
| 151 | 643 |
setattr(cls, "getactionList", getactionList) |
| 2 | 644 |
|
| 151 | 645 |
def removeaction(self, name): |
| 2 | 646 |
if self.actions: |
| 151 | 647 |
actions = self.actions.getaction() |
| 2 | 648 |
i = 0 |
649 |
removed = False |
|
650 |
while i < len(actions) and not removed: |
|
| 151 | 651 |
if actions[i].getname() == name: |
| 46 | 652 |
actions.pop(i) |
| 2 | 653 |
removed = True |
654 |
i += 1 |
|
655 |
if not removed: |
|
656 |
raise ValueError, "Action with name %s doesn't exists!"%name |
|
| 151 | 657 |
setattr(cls, "removeaction", removeaction) |
| 2 | 658 |
|
| 58 | 659 |
def updateElementName(self, old_name, new_name): |
660 |
self.body.updateElementName(old_name, new_name) |
|
| 151 | 661 |
for action in self.getactionList(): |
| 58 | 662 |
action.updateElementName(old_name, new_name) |
| 151 | 663 |
for transition in self.gettransitionList(): |
| 58 | 664 |
transition.updateElementName(old_name, new_name) |
665 |
setattr(cls, "updateElementName", updateElementName) |
|
666 |
||
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
667 |
cls = PLCOpenClasses.get("transitions_transition", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
668 |
if cls: |
| 151 | 669 |
setattr(cls, "setbodyType", setbodyType) |
670 |
setattr(cls, "getbodyType", getbodyType) |
|
671 |
setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
|
672 |
setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
|
673 |
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) |
|
674 |
setattr(cls, "addinstance", addinstance) |
|
675 |
setattr(cls, "getinstances", getinstances) |
|
676 |
setattr(cls, "getinstance", getinstance) |
|
677 |
setattr(cls, "getrandomInstance", getrandomInstance) |
|
678 |
setattr(cls, "getinstanceByName", getinstanceByName) |
|
679 |
setattr(cls, "removeinstance", removeinstance) |
|
680 |
setattr(cls, "settext", settext) |
|
681 |
setattr(cls, "gettext", gettext) |
|
| 2 | 682 |
|
| 58 | 683 |
def updateElementName(self, old_name, new_name): |
684 |
self.body.updateElementName(old_name, new_name) |
|
685 |
setattr(cls, "updateElementName", updateElementName) |
|
686 |
||
| 151 | 687 |
def hasblock(self, name): |
688 |
if self.getbodyType() in ["FBD", "LD", "SFC"]: |
|
689 |
for instance in self.getinstances(): |
|
690 |
if isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and instance.getinstanceName() == name: |
|
|
68
66308e07402c
Adding support for allowing declarations of function block into POU interface
lbessard
parents:
67
diff
changeset
|
691 |
return True |
|
66308e07402c
Adding support for allowing declarations of function block into POU interface
lbessard
parents:
67
diff
changeset
|
692 |
return False |
| 151 | 693 |
setattr(cls, "hasblock", hasblock) |
|
68
66308e07402c
Adding support for allowing declarations of function block into POU interface
lbessard
parents:
67
diff
changeset
|
694 |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
695 |
cls = PLCOpenClasses.get("actions_action", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
696 |
if cls: |
| 151 | 697 |
setattr(cls, "setbodyType", setbodyType) |
698 |
setattr(cls, "getbodyType", getbodyType) |
|
699 |
setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
|
700 |
setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
|
701 |
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) |
|
702 |
setattr(cls, "addinstance", addinstance) |
|
703 |
setattr(cls, "getinstances", getinstances) |
|
704 |
setattr(cls, "getinstance", getinstance) |
|
705 |
setattr(cls, "getrandomInstance", getrandomInstance) |
|
706 |
setattr(cls, "getinstanceByName", getinstanceByName) |
|
707 |
setattr(cls, "removeinstance", removeinstance) |
|
708 |
setattr(cls, "settext", settext) |
|
709 |
setattr(cls, "gettext", gettext) |
|
| 2 | 710 |
|
| 58 | 711 |
def updateElementName(self, old_name, new_name): |
712 |
self.body.updateElementName(old_name, new_name) |
|
713 |
setattr(cls, "updateElementName", updateElementName) |
|
714 |
||
| 151 | 715 |
def hasblock(self, name): |
716 |
if self.getbodyType() in ["FBD", "LD", "SFC"]: |
|
717 |
for instance in self.getinstances(): |
|
718 |
if isinstance(instance, PLCOpenClasses["fbdObjects_block"]) and instance.getinstanceName() == name: |
|
|
68
66308e07402c
Adding support for allowing declarations of function block into POU interface
lbessard
parents:
67
diff
changeset
|
719 |
return True |
|
66308e07402c
Adding support for allowing declarations of function block into POU interface
lbessard
parents:
67
diff
changeset
|
720 |
return False |
| 151 | 721 |
setattr(cls, "hasblock", hasblock) |
|
68
66308e07402c
Adding support for allowing declarations of function block into POU interface
lbessard
parents:
67
diff
changeset
|
722 |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
723 |
cls = PLCOpenClasses.get("body", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
724 |
if cls: |
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
725 |
cls.currentExecutionOrderId = 0 |
|
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
726 |
|
| 151 | 727 |
def resetcurrentExecutionOrderId(self): |
| 200 | 728 |
object.__setattr__(self, "currentExecutionOrderId", 0) |
| 151 | 729 |
setattr(cls, "resetcurrentExecutionOrderId", resetcurrentExecutionOrderId) |
730 |
||
731 |
def getnewExecutionOrderId(self): |
|
| 200 | 732 |
object.__setattr__(self, "currentExecutionOrderId", self.currentExecutionOrderId + 1) |
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
733 |
return self.currentExecutionOrderId |
| 151 | 734 |
setattr(cls, "getnewExecutionOrderId", getnewExecutionOrderId) |
735 |
||
736 |
def resetexecutionOrder(self): |
|
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
737 |
if self.content["name"] == "FBD": |
| 151 | 738 |
for element in self.content["value"].getcontent(): |
739 |
if not isinstance(element["value"], (PLCOpenClasses.get("commonObjects_comment", None),
|
|
740 |
PLCOpenClasses.get("commonObjects_connector", None),
|
|
741 |
PLCOpenClasses.get("commonObjects_continuation", None))):
|
|
742 |
element["value"].setexecutionOrderId(0) |
|
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
743 |
else: |
|
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
744 |
raise TypeError, "Can only generate execution order on FBD networks!" |
| 151 | 745 |
setattr(cls, "resetexecutionOrder", resetexecutionOrder) |
746 |
||
747 |
def compileexecutionOrder(self): |
|
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
748 |
if self.content["name"] == "FBD": |
| 151 | 749 |
self.resetexecutionOrder() |
750 |
self.resetcurrentExecutionOrderId() |
|
751 |
for element in self.content["value"].getcontent(): |
|
| 200 | 752 |
if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_outVariable", None)) and element["value"].getexecutionOrderId() == 0:
|
| 151 | 753 |
connections = element["value"].connectionPointIn.getconnections() |
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
754 |
if connections and len(connections) == 1: |
| 151 | 755 |
self.compileelementExecutionOrder(connections[0]) |
756 |
element["value"].setexecutionOrderId(self.getnewExecutionOrderId()) |
|
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
757 |
else: |
|
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
758 |
raise TypeError, "Can only generate execution order on FBD networks!" |
| 151 | 759 |
setattr(cls, "compileexecutionOrder", compileexecutionOrder) |
760 |
||
761 |
def compileelementExecutionOrder(self, link): |
|
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
762 |
if self.content["name"] == "FBD": |
| 151 | 763 |
localid = link.getrefLocalId() |
764 |
instance = self.getcontentInstance(localid) |
|
765 |
if isinstance(instance, PLCOpenClasses.get("fbdObjects_block", None)) and instance.getexecutionOrderId() == 0:
|
|
766 |
for variable in instance.inputVariables.getvariable(): |
|
767 |
connections = variable.connectionPointIn.getconnections() |
|
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
768 |
if connections and len(connections) == 1: |
| 151 | 769 |
self.compileelementExecutionOrder(connections[0]) |
770 |
instance.setexecutionOrderId(self.getnewExecutionOrderId()) |
|
771 |
elif isinstance(instance, PLCOpenClasses.get("commonObjects_continuation", None)) and instance.getexecutionOrderId() == 0:
|
|
772 |
name = instance.getname() |
|
773 |
for tmp_instance in self.getcontentInstances(): |
|
774 |
if isinstance(tmp_instance, PLCOpenClasses.get("commonObjects_connector", None)) and tmp_instance.getname() == name and tmp_instance.getexecutionOrderId() == 0:
|
|
775 |
connections = tmp_instance.connectionPointIn.getconnections() |
|
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
776 |
if connections and len(connections) == 1: |
| 151 | 777 |
self.compileelementExecutionOrder(connections[0]) |
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
778 |
else: |
|
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
779 |
raise TypeError, "Can only generate execution order on FBD networks!" |
| 151 | 780 |
setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder) |
781 |
||
782 |
def setelementExecutionOrder(self, instance, new_executionOrder): |
|
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
783 |
if self.content["name"] == "FBD": |
| 151 | 784 |
old_executionOrder = instance.getexecutionOrderId() |
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
785 |
if old_executionOrder is not None and old_executionOrder != 0 and new_executionOrder != 0: |
| 151 | 786 |
for element in self.content["value"].getcontent(): |
787 |
if element["value"] != instance and not isinstance(element["value"], PLCOpenClasses.get("commonObjects_comment", None)):
|
|
788 |
element_executionOrder = element["value"].getexecutionOrderId() |
|
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
789 |
if old_executionOrder <= element_executionOrder <= new_executionOrder: |
| 151 | 790 |
element["value"].setexecutionOrderId(element_executionOrder - 1) |
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
791 |
if new_executionOrder <= element_executionOrder <= old_executionOrder: |
| 151 | 792 |
element["value"].setexecutionOrderId(element_executionOrder + 1) |
793 |
instance.setexecutionOrderId(new_executionOrder) |
|
|
118
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
794 |
else: |
|
0c53d6a36013
Add support for defining execution order in FBD networks (related ST code not generated yet)
lbessard
parents:
108
diff
changeset
|
795 |
raise TypeError, "Can only generate execution order on FBD networks!" |
| 151 | 796 |
setattr(cls, "setelementExecutionOrder", setelementExecutionOrder) |
797 |
||
798 |
def appendcontentInstance(self, name, instance): |
|
| 2 | 799 |
if self.content["name"] in ["LD","FBD","SFC"]: |
| 151 | 800 |
self.content["value"].appendcontent({"name" : name, "value" : instance})
|
| 2 | 801 |
else: |
802 |
raise TypeError, "%s body don't have instances!"%self.content["name"] |
|
| 151 | 803 |
setattr(cls, "appendcontentInstance", appendcontentInstance) |
804 |
||
805 |
def getcontentInstances(self): |
|
| 2 | 806 |
if self.content["name"] in ["LD","FBD","SFC"]: |
807 |
instances = [] |
|
| 151 | 808 |
for element in self.content["value"].getcontent(): |
| 2 | 809 |
instances.append(element["value"]) |
810 |
return instances |
|
811 |
else: |
|
812 |
raise TypeError, "%s body don't have instances!"%self.content["name"] |
|
| 151 | 813 |
setattr(cls, "getcontentInstances", getcontentInstances) |
814 |
||
815 |
def getcontentInstance(self, id): |
|
| 2 | 816 |
if self.content["name"] in ["LD","FBD","SFC"]: |
| 151 | 817 |
for element in self.content["value"].getcontent(): |
818 |
if element["value"].getlocalId() == id: |
|
| 2 | 819 |
return element["value"] |
| 0 | 820 |
return None |
| 2 | 821 |
else: |
822 |
raise TypeError, "%s body don't have instances!"%self.content["name"] |
|
| 151 | 823 |
setattr(cls, "getcontentInstance", getcontentInstance) |
824 |
||
825 |
def getcontentRandomInstance(self, exclude): |
|
| 2 | 826 |
if self.content["name"] in ["LD","FBD","SFC"]: |
| 151 | 827 |
for element in self.content["value"].getcontent(): |
828 |
if element["value"].getlocalId() not in exclude: |
|
| 2 | 829 |
return element["value"] |
830 |
return None |
|
831 |
else: |
|
832 |
raise TypeError, "%s body don't have instances!"%self.content["name"] |
|
| 151 | 833 |
setattr(cls, "getcontentRandomInstance", getcontentRandomInstance) |
834 |
||
835 |
def getcontentInstanceByName(self, name): |
|
| 2 | 836 |
if self.content["name"] in ["LD","FBD","SFC"]: |
| 151 | 837 |
for element in self.content["value"].getcontent(): |
| 193 | 838 |
if isinstance(element["value"], PLCOpenClasses.get("fbdObjects_block", None)) and element["value"].getinstanceName() == name:
|
| 2 | 839 |
return element["value"] |
840 |
else: |
|
841 |
raise TypeError, "%s body don't have instances!"%self.content["name"] |
|
| 151 | 842 |
setattr(cls, "getcontentInstanceByName", getcontentInstanceByName) |
843 |
||
844 |
def removecontentInstance(self, id): |
|
| 2 | 845 |
if self.content["name"] in ["LD","FBD","SFC"]: |
846 |
i = 0 |
|
847 |
removed = False |
|
| 151 | 848 |
elements = self.content["value"].getcontent() |
| 2 | 849 |
while i < len(elements) and not removed: |
| 151 | 850 |
if elements[i]["value"].getlocalId() == id: |
851 |
self.content["value"].removecontent(i) |
|
| 2 | 852 |
removed = True |
853 |
i += 1 |
|
854 |
if not removed: |
|
855 |
raise ValueError, "Instance with id %d doesn't exists!"%id |
|
856 |
else: |
|
857 |
raise TypeError, "%s body don't have instances!"%self.content["name"] |
|
| 151 | 858 |
setattr(cls, "removecontentInstance", removecontentInstance) |
859 |
||
860 |
def settext(self, text): |
|
| 2 | 861 |
if self.content["name"] in ["IL","ST"]: |
| 151 | 862 |
self.content["value"].settext(text) |
| 2 | 863 |
else: |
864 |
raise TypeError, "%s body don't have text!"%self.content["name"] |
|
| 151 | 865 |
setattr(cls, "settext", settext) |
866 |
||
867 |
def gettext(self): |
|
| 2 | 868 |
if self.content["name"] in ["IL","ST"]: |
| 151 | 869 |
return self.content["value"].gettext() |
| 2 | 870 |
else: |
871 |
raise TypeError, "%s body don't have text!"%self.content["name"] |
|
| 151 | 872 |
setattr(cls, "gettext", gettext) |
| 58 | 873 |
|
874 |
def updateElementName(self, old_name, new_name): |
|
875 |
if self.content["name"] in ["IL", "ST"]: |
|
876 |
self.content["value"].updateElementName(old_name, new_name) |
|
877 |
else: |
|
| 151 | 878 |
for element in self.content["value"].getcontent(): |
| 58 | 879 |
element["value"].updateElementName(old_name, new_name) |
880 |
setattr(cls, "updateElementName", updateElementName) |
|
| 2 | 881 |
|
| 151 | 882 |
def getx(self): |
883 |
return self.position.getx() |
|
884 |
||
885 |
def gety(self): |
|
886 |
return self.position.gety() |
|
887 |
||
888 |
def setx(self, x): |
|
889 |
self.position.setx(x) |
|
890 |
||
891 |
def sety(self, y): |
|
892 |
self.position.sety(y) |
|
893 |
||
894 |
cls = PLCOpenClasses.get("commonObjects_comment", None)
|
|
895 |
if cls: |
|
896 |
setattr(cls, "getx", getx) |
|
897 |
setattr(cls, "gety", gety) |
|
898 |
setattr(cls, "setx", setx) |
|
899 |
setattr(cls, "sety", sety) |
|
900 |
||
901 |
def setcontentText(self, text): |
|
902 |
self.content.settext(text) |
|
903 |
setattr(cls, "setcontentText", setcontentText) |
|
| 0 | 904 |
|
| 151 | 905 |
def getcontentText(self): |
906 |
return self.content.gettext() |
|
907 |
setattr(cls, "getcontentText", getcontentText) |
|
| 58 | 908 |
|
909 |
def updateElementName(self, old_name, new_name): |
|
910 |
self.content.updateElementName(old_name, new_name) |
|
911 |
setattr(cls, "updateElementName", updateElementName) |
|
| 2 | 912 |
|
| 151 | 913 |
cls = PLCOpenClasses.get("fbdObjects_block", None)
|
914 |
if cls: |
|
915 |
setattr(cls, "getx", getx) |
|
916 |
setattr(cls, "gety", gety) |
|
917 |
setattr(cls, "setx", setx) |
|
918 |
setattr(cls, "sety", sety) |
|
| 2 | 919 |
|
| 58 | 920 |
def updateElementName(self, old_name, new_name): |
921 |
if self.typeName == old_name: |
|
922 |
self.typeName = new_name |
|
923 |
setattr(cls, "updateElementName", updateElementName) |
|
924 |
||
| 151 | 925 |
cls = PLCOpenClasses.get("ldObjects_leftPowerRail", None)
|
926 |
if cls: |
|
927 |
setattr(cls, "getx", getx) |
|
928 |
setattr(cls, "gety", gety) |
|
929 |
setattr(cls, "setx", setx) |
|
930 |
setattr(cls, "sety", sety) |
|
| 2 | 931 |
|
| 58 | 932 |
def updateElementName(self, old_name, new_name): |
933 |
pass |
|
934 |
setattr(cls, "updateElementName", updateElementName) |
|
935 |
||
| 151 | 936 |
cls = PLCOpenClasses.get("ldObjects_rightPowerRail", None)
|
937 |
if cls: |
|
938 |
setattr(cls, "getx", getx) |
|
939 |
setattr(cls, "gety", gety) |
|
940 |
setattr(cls, "setx", setx) |
|
941 |
setattr(cls, "sety", sety) |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
942 |
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
943 |
def updateElementName(self, old_name, new_name): |
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
944 |
pass |
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
945 |
setattr(cls, "updateElementName", updateElementName) |
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
946 |
|
| 151 | 947 |
cls = PLCOpenClasses.get("ldObjects_contact", None)
|
948 |
if cls: |
|
949 |
setattr(cls, "getx", getx) |
|
950 |
setattr(cls, "gety", gety) |
|
951 |
setattr(cls, "setx", setx) |
|
952 |
setattr(cls, "sety", sety) |
|
| 2 | 953 |
|
| 58 | 954 |
def updateElementName(self, old_name, new_name): |
955 |
if self.variable == old_name: |
|
956 |
self.variable = new_name |
|
957 |
setattr(cls, "updateElementName", updateElementName) |
|
958 |
||
| 151 | 959 |
cls = PLCOpenClasses.get("ldObjects_coil", None)
|
960 |
if cls: |
|
961 |
setattr(cls, "getx", getx) |
|
962 |
setattr(cls, "gety", gety) |
|
963 |
setattr(cls, "setx", setx) |
|
964 |
setattr(cls, "sety", sety) |
|
| 2 | 965 |
|
| 58 | 966 |
def updateElementName(self, old_name, new_name): |
967 |
if self.variable == old_name: |
|
968 |
self.variable = new_name |
|
969 |
setattr(cls, "updateElementName", updateElementName) |
|
970 |
||
| 151 | 971 |
cls = PLCOpenClasses.get("sfcObjects_step", None)
|
972 |
if cls: |
|
973 |
setattr(cls, "getx", getx) |
|
974 |
setattr(cls, "gety", gety) |
|
975 |
setattr(cls, "setx", setx) |
|
976 |
setattr(cls, "sety", sety) |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
977 |
|
| 58 | 978 |
def updateElementName(self, old_name, new_name): |
979 |
pass |
|
980 |
setattr(cls, "updateElementName", updateElementName) |
|
| 2 | 981 |
|
| 151 | 982 |
cls = PLCOpenClasses.get("sfcObjects_transition", None)
|
983 |
if cls: |
|
984 |
setattr(cls, "getx", getx) |
|
985 |
setattr(cls, "gety", gety) |
|
986 |
setattr(cls, "setx", setx) |
|
987 |
setattr(cls, "sety", sety) |
|
988 |
||
989 |
def setconditionContent(self, type, value): |
|
| 2 | 990 |
if not self.condition: |
| 151 | 991 |
self.addcondition() |
| 2 | 992 |
if type == "reference": |
993 |
condition = PLCOpenClasses["condition_reference"]() |
|
| 151 | 994 |
condition.setname(value) |
| 2 | 995 |
elif type == "inline": |
996 |
condition = PLCOpenClasses["condition_inline"]() |
|
| 151 | 997 |
condition.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
|
998 |
condition.settext(value) |
|
| 69 | 999 |
elif type == "connection": |
| 166 | 1000 |
condition = [PLCOpenClasses["connection"]()] |
| 151 | 1001 |
self.condition.setcontent({"name" : type, "value" : condition})
|
1002 |
setattr(cls, "setconditionContent", setconditionContent) |
|
| 0 | 1003 |
|
| 151 | 1004 |
def getconditionContent(self): |
| 2 | 1005 |
if self.condition: |
| 151 | 1006 |
content = self.condition.getcontent() |
| 2 | 1007 |
values = {"type" : content["name"]}
|
1008 |
if values["type"] == "reference": |
|
| 151 | 1009 |
values["value"] = content["value"].getname() |
| 2 | 1010 |
elif values["type"] == "inline": |
| 151 | 1011 |
values["value"] = content["value"].gettext() |
| 2 | 1012 |
return values |
1013 |
return "" |
|
| 151 | 1014 |
setattr(cls, "getconditionContent", getconditionContent) |
| 2 | 1015 |
|
| 58 | 1016 |
def updateElementName(self, old_name, new_name): |
1017 |
if self.condition: |
|
| 151 | 1018 |
content = self.condition.getcontent() |
| 58 | 1019 |
if content["name"] == "reference": |
| 151 | 1020 |
if content["value"].getname() == old_name: |
1021 |
content["value"].setname(new_name) |
|
| 58 | 1022 |
elif content["name"] == "inline": |
1023 |
content["value"].updateElementName(old_name, new_name) |
|
1024 |
setattr(cls, "updateElementName", updateElementName) |
|
1025 |
||
| 151 | 1026 |
def addconnection(self): |
| 69 | 1027 |
if self.condition: |
| 151 | 1028 |
content = self.condition.getcontent() |
| 69 | 1029 |
if content["name"] != "connection": |
| 166 | 1030 |
self.condition.setcontent({"name" : "connection", "value" : [PLCOpenClasses["connection"]()]})
|
| 151 | 1031 |
content = self.condition.getcontent() |
| 166 | 1032 |
else: |
1033 |
content["value"].append(PLCOpenClasses["connection"]()) |
|
| 151 | 1034 |
setattr(cls, "addconnection", addconnection) |
1035 |
||
1036 |
def removeconnection(self, idx): |
|
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1037 |
if self.condition: |
| 151 | 1038 |
content = self.condition.getcontent() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1039 |
if content["name"] == "connection": |
|
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1040 |
content["value"].pop(idx) |
| 151 | 1041 |
setattr(cls, "removeconnection", removeconnection) |
1042 |
||
1043 |
def removeconnections(self): |
|
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1044 |
if self.condition: |
| 151 | 1045 |
content = self.condition.getcontent() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1046 |
if content["name"] == "connection": |
| 166 | 1047 |
content["value"] = [PLCOpenClasses["connection"]()] |
| 151 | 1048 |
setattr(cls, "removeconnections", removeconnections) |
1049 |
||
1050 |
def getconnections(self): |
|
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1051 |
if self.condition: |
| 151 | 1052 |
content = self.condition.getcontent() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1053 |
if content["name"] == "connection": |
|
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1054 |
return content["value"] |
| 151 | 1055 |
setattr(cls, "getconnections", getconnections) |
1056 |
||
1057 |
def setconnectionId(self, idx, id): |
|
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1058 |
if self.condition: |
| 151 | 1059 |
content = self.condition.getcontent() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1060 |
if content["name"] == "connection": |
| 151 | 1061 |
content["value"][idx].setrefLocalId(id) |
1062 |
setattr(cls, "setconnectionId", setconnectionId) |
|
1063 |
||
1064 |
def getconnectionId(self, idx): |
|
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1065 |
if self.condition: |
| 151 | 1066 |
content = self.condition.getcontent() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1067 |
if content["name"] == "connection": |
| 151 | 1068 |
return content["value"][idx].getrefLocalId() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1069 |
return None |
| 151 | 1070 |
setattr(cls, "getconnectionId", getconnectionId) |
1071 |
||
1072 |
def setconnectionPoints(self, idx, points): |
|
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1073 |
if self.condition: |
| 151 | 1074 |
content = self.condition.getcontent() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1075 |
if content["name"] == "connection": |
| 151 | 1076 |
content["value"][idx].setpoints(points) |
1077 |
setattr(cls, "setconnectionPoints", setconnectionPoints) |
|
1078 |
||
1079 |
def getconnectionPoints(self, idx): |
|
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1080 |
if self.condition: |
| 151 | 1081 |
content = self.condition.getcontent() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1082 |
if content["name"] == "connection": |
| 151 | 1083 |
return content["value"][idx].getpoints() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1084 |
return None |
| 151 | 1085 |
setattr(cls, "getconnectionPoints", getconnectionPoints) |
1086 |
||
1087 |
def setconnectionParameter(self, idx, parameter): |
|
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1088 |
if self.condition: |
| 151 | 1089 |
content = self.condition.getcontent() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1090 |
if content["name"] == "connection": |
| 151 | 1091 |
content["value"][idx].setformalParameter(parameter) |
1092 |
setattr(cls, "setconnectionParameter", setconnectionParameter) |
|
1093 |
||
1094 |
def getconnectionParameter(self, idx): |
|
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1095 |
if self.condition: |
| 151 | 1096 |
content = self.condition.getcontent() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1097 |
if content["name"] == "connection": |
| 151 | 1098 |
return content["value"][idx].getformalParameter() |
|
63
04a02b4b2a57
Adding support for connecting transition to LD rung and FBD network
lbessard
parents:
58
diff
changeset
|
1099 |
return None |
| 151 | 1100 |
setattr(cls, "getconnectionParameter", getconnectionParameter) |
1101 |
||
1102 |
cls = PLCOpenClasses.get("sfcObjects_selectionDivergence", None)
|
|
1103 |
if cls: |
|
1104 |
setattr(cls, "getx", getx) |
|
1105 |
setattr(cls, "gety", gety) |
|
1106 |
setattr(cls, "setx", setx) |
|
1107 |
setattr(cls, "sety", sety) |
|
| 2 | 1108 |
|
| 58 | 1109 |
def updateElementName(self, old_name, new_name): |
1110 |
pass |
|
1111 |
setattr(cls, "updateElementName", updateElementName) |
|
1112 |
||
| 151 | 1113 |
cls = PLCOpenClasses.get("sfcObjects_selectionConvergence", None)
|
1114 |
if cls: |
|
1115 |
setattr(cls, "getx", getx) |
|
1116 |
setattr(cls, "gety", gety) |
|
1117 |
setattr(cls, "setx", setx) |
|
1118 |
setattr(cls, "sety", sety) |
|
| 2 | 1119 |
|
| 58 | 1120 |
def updateElementName(self, old_name, new_name): |
1121 |
pass |
|
1122 |
setattr(cls, "updateElementName", updateElementName) |
|
1123 |
||
| 151 | 1124 |
cls = PLCOpenClasses.get("sfcObjects_simultaneousDivergence", None)
|
1125 |
if cls: |
|
1126 |
setattr(cls, "getx", getx) |
|
1127 |
setattr(cls, "gety", gety) |
|
1128 |
setattr(cls, "setx", setx) |
|
1129 |
setattr(cls, "sety", sety) |
|
| 2 | 1130 |
|
| 58 | 1131 |
def updateElementName(self, old_name, new_name): |
1132 |
pass |
|
1133 |
setattr(cls, "updateElementName", updateElementName) |
|
1134 |
||
| 151 | 1135 |
cls = PLCOpenClasses.get("sfcObjects_simultaneousConvergence", None)
|
1136 |
if cls: |
|
1137 |
setattr(cls, "getx", getx) |
|
1138 |
setattr(cls, "gety", gety) |
|
1139 |
setattr(cls, "setx", setx) |
|
1140 |
setattr(cls, "sety", sety) |
|
| 58 | 1141 |
|
1142 |
def updateElementName(self, old_name, new_name): |
|
1143 |
pass |
|
1144 |
setattr(cls, "updateElementName", updateElementName) |
|
| 2 | 1145 |
|
| 151 | 1146 |
cls = PLCOpenClasses.get("sfcObjects_jumpStep", None)
|
1147 |
if cls: |
|
1148 |
setattr(cls, "getx", getx) |
|
1149 |
setattr(cls, "gety", gety) |
|
1150 |
setattr(cls, "setx", setx) |
|
1151 |
setattr(cls, "sety", sety) |
|
| 58 | 1152 |
|
1153 |
def updateElementName(self, old_name, new_name): |
|
1154 |
pass |
|
1155 |
setattr(cls, "updateElementName", updateElementName) |
|
1156 |
||
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1157 |
cls = PLCOpenClasses.get("actionBlock_action", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1158 |
if cls: |
| 151 | 1159 |
def setreferenceName(self, name): |
1160 |
if self.reference: |
|
1161 |
self.reference.setname(name) |
|
1162 |
setattr(cls, "setreferenceName", setreferenceName) |
|
1163 |
||
1164 |
def getreferenceName(self): |
|
1165 |
if self.reference: |
|
1166 |
return self.reference.getname() |
|
| 2 | 1167 |
return None |
| 151 | 1168 |
setattr(cls, "getreferenceName", getreferenceName) |
1169 |
||
1170 |
def setinlineContent(self, content): |
|
1171 |
if self.inline: |
|
1172 |
self.inline.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})
|
|
1173 |
self.inline.settext(content) |
|
1174 |
setattr(cls, "setinlineContent", setinlineContent) |
|
1175 |
||
1176 |
def getinlineContent(self): |
|
1177 |
if self.inline: |
|
1178 |
return self.inline.gettext() |
|
| 2 | 1179 |
return None |
| 151 | 1180 |
setattr(cls, "getinlineContent", getinlineContent) |
1181 |
||
1182 |
def updateElementName(self, old_name, new_name): |
|
1183 |
if self.reference and self.reference.getname() == old_name: |
|
1184 |
self.reference.setname(new_name) |
|
| 58 | 1185 |
if self.inline: |
1186 |
self.inline.updateElementName(old_name, new_name) |
|
1187 |
setattr(cls, "updateElementName", updateElementName) |
|
1188 |
||
| 151 | 1189 |
cls = PLCOpenClasses.get("commonObjects_actionBlock", None)
|
1190 |
if cls: |
|
1191 |
setattr(cls, "getx", getx) |
|
1192 |
setattr(cls, "gety", gety) |
|
1193 |
setattr(cls, "setx", setx) |
|
1194 |
setattr(cls, "sety", sety) |
|
1195 |
||
1196 |
def setactions(self, actions): |
|
| 2 | 1197 |
self.action = [] |
1198 |
for params in actions: |
|
1199 |
action = PLCOpenClasses["actionBlock_action"]() |
|
| 151 | 1200 |
action.setqualifier(params["qualifier"]) |
| 2 | 1201 |
if params["type"] == "reference": |
| 151 | 1202 |
action.addreference() |
1203 |
action.setreferenceName(params["value"]) |
|
| 0 | 1204 |
else: |
| 151 | 1205 |
action.addinline() |
1206 |
action.setinlineContent(params["value"]) |
|
| 2 | 1207 |
if "duration" in params: |
| 151 | 1208 |
action.setduration(params["duration"]) |
| 2 | 1209 |
if "indicator" in params: |
| 151 | 1210 |
action.setindicator(params["indicator"]) |
| 2 | 1211 |
self.action.append(action) |
| 151 | 1212 |
setattr(cls, "setactions", setactions) |
1213 |
||
1214 |
def getactions(self): |
|
| 2 | 1215 |
actions = [] |
1216 |
for action in self.action: |
|
1217 |
params = {}
|
|
| 151 | 1218 |
params["qualifier"] = action.getqualifier() |
| 108 | 1219 |
if params["qualifier"] is None: |
1220 |
params["qualifier"] = "N" |
|
| 151 | 1221 |
if action.getreference(): |
| 2 | 1222 |
params["type"] = "reference" |
| 151 | 1223 |
params["value"] = action.getreferenceName() |
1224 |
elif action.getinline(): |
|
| 2 | 1225 |
params["type"] = "inline" |
| 151 | 1226 |
params["value"] = action.getinlineContent() |
1227 |
duration = action.getduration() |
|
| 2 | 1228 |
if duration: |
1229 |
params["duration"] = duration |
|
| 151 | 1230 |
indicator = action.getindicator() |
| 2 | 1231 |
if indicator: |
1232 |
params["indicator"] = indicator |
|
1233 |
actions.append(params) |
|
1234 |
return actions |
|
| 151 | 1235 |
setattr(cls, "getactions", getactions) |
| 2 | 1236 |
|
| 58 | 1237 |
def updateElementName(self, old_name, new_name): |
1238 |
for action in self.action: |
|
1239 |
action.updateElementName(old_name, new_name) |
|
1240 |
setattr(cls, "updateElementName", updateElementName) |
|
1241 |
||
| 151 | 1242 |
cls = PLCOpenClasses.get("fbdObjects_inVariable", None)
|
1243 |
if cls: |
|
1244 |
setattr(cls, "getx", getx) |
|
1245 |
setattr(cls, "gety", gety) |
|
1246 |
setattr(cls, "setx", setx) |
|
1247 |
setattr(cls, "sety", sety) |
|
| 58 | 1248 |
|
1249 |
def updateElementName(self, old_name, new_name): |
|
1250 |
if self.expression == old_name: |
|
1251 |
self.expression = new_name |
|
1252 |
setattr(cls, "updateElementName", updateElementName) |
|
| 2 | 1253 |
|
| 151 | 1254 |
cls = PLCOpenClasses.get("fbdObjects_outVariable", None)
|
1255 |
if cls: |
|
1256 |
setattr(cls, "getx", getx) |
|
1257 |
setattr(cls, "gety", gety) |
|
1258 |
setattr(cls, "setx", setx) |
|
1259 |
setattr(cls, "sety", sety) |
|
| 2 | 1260 |
|
| 58 | 1261 |
def updateElementName(self, old_name, new_name): |
1262 |
if self.expression == old_name: |
|
1263 |
self.expression = new_name |
|
1264 |
setattr(cls, "updateElementName", updateElementName) |
|
1265 |
||
| 151 | 1266 |
cls = PLCOpenClasses.get("fbdObjects_inOutVariable", None)
|
1267 |
if cls: |
|
1268 |
setattr(cls, "getx", getx) |
|
1269 |
setattr(cls, "gety", gety) |
|
1270 |
setattr(cls, "setx", setx) |
|
1271 |
setattr(cls, "sety", sety) |
|
| 2 | 1272 |
|
| 58 | 1273 |
def updateElementName(self, old_name, new_name): |
1274 |
if self.expression == old_name: |
|
1275 |
self.expression = new_name |
|
1276 |
setattr(cls, "updateElementName", updateElementName) |
|
1277 |
||
| 151 | 1278 |
cls = PLCOpenClasses.get("commonObjects_continuation", None)
|
1279 |
if cls: |
|
1280 |
setattr(cls, "getx", getx) |
|
1281 |
setattr(cls, "gety", gety) |
|
1282 |
setattr(cls, "setx", setx) |
|
1283 |
setattr(cls, "sety", sety) |
|
| 58 | 1284 |
|
1285 |
def updateElementName(self, old_name, new_name): |
|
1286 |
pass |
|
1287 |
setattr(cls, "updateElementName", updateElementName) |
|
| 2 | 1288 |
|
| 151 | 1289 |
cls = PLCOpenClasses.get("commonObjects_connector", None)
|
1290 |
if cls: |
|
1291 |
setattr(cls, "getx", getx) |
|
1292 |
setattr(cls, "gety", gety) |
|
1293 |
setattr(cls, "setx", setx) |
|
1294 |
setattr(cls, "sety", sety) |
|
| 58 | 1295 |
|
1296 |
def updateElementName(self, old_name, new_name): |
|
1297 |
pass |
|
1298 |
setattr(cls, "updateElementName", updateElementName) |
|
| 2 | 1299 |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1300 |
cls = PLCOpenClasses.get("connection", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1301 |
if cls: |
| 151 | 1302 |
def setpoints(self, points): |
| 2 | 1303 |
self.position = [] |
1304 |
for point in points: |
|
1305 |
position = PLCOpenClasses["position"]() |
|
| 151 | 1306 |
position.setx(point.x) |
1307 |
position.sety(point.y) |
|
| 2 | 1308 |
self.position.append(position) |
| 151 | 1309 |
setattr(cls, "setpoints", setpoints) |
1310 |
||
1311 |
def getpoints(self): |
|
| 2 | 1312 |
points = [] |
1313 |
for position in self.position: |
|
| 151 | 1314 |
points.append((position.getx(),position.gety())) |
| 2 | 1315 |
return points |
| 151 | 1316 |
setattr(cls, "getpoints", getpoints) |
| 2 | 1317 |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1318 |
cls = PLCOpenClasses.get("connectionPointIn", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1319 |
if cls: |
| 151 | 1320 |
def setrelPositionXY(self, x, y): |
| 2 | 1321 |
self.relPosition = PLCOpenClasses["position"]() |
| 151 | 1322 |
self.relPosition.setx(x) |
1323 |
self.relPosition.sety(y) |
|
1324 |
setattr(cls, "setrelPositionXY", setrelPositionXY) |
|
1325 |
||
1326 |
def getrelPositionXY(self): |
|
| 2 | 1327 |
if self.relPosition: |
| 151 | 1328 |
return self.relPosition.getx(), self.relPosition.gety() |
| 2 | 1329 |
else: |
| 0 | 1330 |
return self.relPosition |
| 151 | 1331 |
setattr(cls, "getrelPositionXY", getrelPositionXY) |
1332 |
||
1333 |
def addconnection(self): |
|
| 2 | 1334 |
if not self.content: |
| 151 | 1335 |
self.content = {"name" : "connection", "value" : [PLCOpenClasses["connection"]()]}
|
| 2 | 1336 |
else: |
1337 |
self.content["value"].append(PLCOpenClasses["connection"]()) |
|
| 151 | 1338 |
setattr(cls, "addconnection", addconnection) |
1339 |
||
1340 |
def removeconnection(self, idx): |
|
| 2 | 1341 |
if self.content: |
1342 |
self.content["value"].pop(idx) |
|
1343 |
if len(self.content["value"]) == 0: |
|
1344 |
self.content = None |
|
| 151 | 1345 |
setattr(cls, "removeconnection", removeconnection) |
1346 |
||
1347 |
def removeconnections(self): |
|
| 2 | 1348 |
if self.content: |
1349 |
self.content = None |
|
| 151 | 1350 |
setattr(cls, "removeconnections", removeconnections) |
1351 |
||
1352 |
def getconnections(self): |
|
| 2 | 1353 |
if self.content: |
1354 |
return self.content["value"] |
|
| 151 | 1355 |
setattr(cls, "getconnections", getconnections) |
1356 |
||
1357 |
def setconnectionId(self, idx, id): |
|
| 2 | 1358 |
if self.content: |
| 151 | 1359 |
self.content["value"][idx].setrefLocalId(id) |
1360 |
setattr(cls, "setconnectionId", setconnectionId) |
|
1361 |
||
1362 |
def getconnectionId(self, idx): |
|
| 2 | 1363 |
if self.content: |
| 151 | 1364 |
return self.content["value"][idx].getrefLocalId() |
| 2 | 1365 |
return None |
| 151 | 1366 |
setattr(cls, "getconnectionId", getconnectionId) |
1367 |
||
1368 |
def setconnectionPoints(self, idx, points): |
|
| 2 | 1369 |
if self.content: |
| 151 | 1370 |
self.content["value"][idx].setpoints(points) |
1371 |
setattr(cls, "setconnectionPoints", setconnectionPoints) |
|
1372 |
||
1373 |
def getconnectionPoints(self, idx): |
|
| 2 | 1374 |
if self.content: |
| 151 | 1375 |
return self.content["value"][idx].getpoints() |
| 2 | 1376 |
return None |
| 151 | 1377 |
setattr(cls, "getconnectionPoints", getconnectionPoints) |
1378 |
||
1379 |
def setconnectionParameter(self, idx, parameter): |
|
| 27 | 1380 |
if self.content: |
| 151 | 1381 |
self.content["value"][idx].setformalParameter(parameter) |
1382 |
setattr(cls, "setconnectionParameter", setconnectionParameter) |
|
1383 |
||
1384 |
def getconnectionParameter(self, idx): |
|
| 27 | 1385 |
if self.content: |
| 151 | 1386 |
return self.content["value"][idx].getformalParameter() |
| 27 | 1387 |
return None |
| 151 | 1388 |
setattr(cls, "getconnectionParameter", getconnectionParameter) |
| 27 | 1389 |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1390 |
cls = PLCOpenClasses.get("connectionPointOut", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1391 |
if cls: |
| 151 | 1392 |
def setrelPositionXY(self, x, y): |
| 2 | 1393 |
self.relPosition = PLCOpenClasses["position"]() |
| 151 | 1394 |
self.relPosition.setx(x) |
1395 |
self.relPosition.sety(y) |
|
1396 |
setattr(cls, "setrelPositionXY", setrelPositionXY) |
|
1397 |
||
1398 |
def getrelPositionXY(self): |
|
| 2 | 1399 |
if self.relPosition: |
| 151 | 1400 |
return self.relPosition.getx(), self.relPosition.gety() |
| 2 | 1401 |
return self.relPosition |
| 151 | 1402 |
setattr(cls, "getrelPositionXY", getrelPositionXY) |
| 2 | 1403 |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1404 |
cls = PLCOpenClasses.get("value", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1405 |
if cls: |
| 151 | 1406 |
def setvalue(self, value): |
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1407 |
if value.startswith("[") and value.endswith("]"):
|
| 2 | 1408 |
arrayValue = PLCOpenClasses["value_arrayValue"]() |
| 151 | 1409 |
self.content = {"name" : "arrayValue", "value" : arrayValue}
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1410 |
elif value.startswith("(") and value.endswith(")"):
|
| 2 | 1411 |
structValue = PLCOpenClasses["value_structValue"]() |
| 151 | 1412 |
self.content = {"name" : "structValue", "value" : structValue}
|
| 2 | 1413 |
else: |
1414 |
simpleValue = PLCOpenClasses["value_simpleValue"]() |
|
| 151 | 1415 |
self.content = {"name" : "simpleValue", "value": simpleValue}
|
1416 |
self.content["value"].setvalue(value) |
|
1417 |
setattr(cls, "setvalue", setvalue) |
|
1418 |
||
1419 |
def getvalue(self): |
|
1420 |
return self.content["value"].getvalue() |
|
1421 |
setattr(cls, "getvalue", getvalue) |
|
| 2 | 1422 |
|
| 147 | 1423 |
def extractValues(values): |
| 145 | 1424 |
items = values.split(",")
|
1425 |
i = 1 |
|
1426 |
while i < len(items): |
|
1427 |
opened = items[i - 1].count("(") + items[i - 1].count("[")
|
|
1428 |
closed = items[i - 1].count(")") + items[i - 1].count("]")
|
|
1429 |
if opened > closed: |
|
1430 |
items[i - 1] = ','.join([items[i - 1], items.pop(i)]) |
|
1431 |
elif opened == closed: |
|
1432 |
i += 1 |
|
1433 |
else: |
|
1434 |
raise ValueError, "\"%s\" is an invalid value!"%value |
|
1435 |
return items |
|
1436 |
||
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1437 |
cls = PLCOpenClasses.get("value_arrayValue", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1438 |
if cls: |
| 145 | 1439 |
arrayValue_model = re.compile("([0-9]*)\((.*)\)$")
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1440 |
|
| 151 | 1441 |
def setvalue(self, value): |
| 2 | 1442 |
self.value = [] |
| 145 | 1443 |
for item in extractValues(value[1:-1]): |
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1444 |
item = item.strip() |
| 2 | 1445 |
element = PLCOpenClasses["arrayValue_value"]() |
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1446 |
result = arrayValue_model.match(item) |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1447 |
if result is not None: |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1448 |
groups = result.groups() |
| 151 | 1449 |
element.setrepetitionValue(int(groups[0])) |
1450 |
element.setvalue(groups[1].strip()) |
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1451 |
else: |
| 151 | 1452 |
element.setvalue(item) |
| 2 | 1453 |
self.value.append(element) |
| 151 | 1454 |
setattr(cls, "setvalue", setvalue) |
1455 |
||
1456 |
def getvalue(self): |
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1457 |
values = [] |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1458 |
for element in self.value: |
| 151 | 1459 |
repetition = element.getrepetitionValue() |
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1460 |
if repetition is not None and repetition > 1: |
| 151 | 1461 |
values.append("%d(%s)"%(repetition, element.getvalue()))
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1462 |
else: |
| 151 | 1463 |
values.append(element.getvalue()) |
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1464 |
return "[%s]"%", ".join(values) |
| 151 | 1465 |
setattr(cls, "getvalue", getvalue) |
| 2 | 1466 |
|
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1467 |
cls = PLCOpenClasses.get("value_structValue", None)
|
|
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
63
diff
changeset
|
1468 |
if cls: |
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1469 |
structValue_model = re.compile("(.*):=(.*)")
|
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1470 |
|
| 151 | 1471 |
def setvalue(self, value): |
| 2 | 1472 |
self.value = [] |
| 145 | 1473 |
for item in extractValues(value[1:-1]): |
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1474 |
result = arrayValue_model.match(item) |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1475 |
if result is not None: |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1476 |
groups = result.groups() |
|
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1477 |
element = PLCOpenClasses["structValue_value"]() |
| 151 | 1478 |
element.setmember(groups[0].strip()) |
1479 |
element.setvalue(groups[1].strip()) |
|
| 2 | 1480 |
self.value.append(element) |
| 151 | 1481 |
setattr(cls, "setvalue", setvalue) |
1482 |
||
1483 |
def getvalue(self): |
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1484 |
values = [] |
| 2 | 1485 |
for element in self.value: |
| 151 | 1486 |
values.append("%s := %s"%(element.getmember(), element.getvalue()))
|
|
125
394d9f168258
Adding support for execution order in PLCGenerator
lbessard
parents:
118
diff
changeset
|
1487 |
return "(%s)"%", ".join(values) |
| 151 | 1488 |
setattr(cls, "getvalue", getvalue) |