author  Andrey Skvortsov <andrej.skvortzov@gmail.com> 
Mon, 28 Nov 2016 16:47:01 +0300  
changeset 1581  2295fdc5c271 
parent 1571  486f94a8032c 
child 1603  18279f12a6be 
permissions  rwrr 
814  1 
#!/usr/bin/env python 
2 
# * coding: utf8 * 

3 

1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

4 
# This file is part of Beremiz, a Integrated Development Environment for 
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

5 
# programming IEC 611313 automates supporting plcopen standard and CanFestival. 
814  6 
# 
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

7 
# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD 
814  8 
# 
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

9 
# See COPYING file for copyrights details. 
814  10 
# 
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

11 
# This program is free software; you can redistribute it and/or 
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

12 
# modify it under the terms of the GNU General Public License 
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

13 
# as published by the Free Software Foundation; either version 2 
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

14 
# of the License, or (at your option) any later version. 
814  15 
# 
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

16 
# This program is distributed in the hope that it will be useful, 
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

17 
# but WITHOUT ANY WARRANTY; without even the implied warranty of 
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

18 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

19 
# GNU General Public License for more details. 
814  20 
# 
1571
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

21 
# You should have received a copy of the GNU General Public License 
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

22 
# along with this program; if not, write to the Free Software 
486f94a8032c
fix license notices in source files and license files under GPLv2+
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1450
diff
changeset

23 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301, USA. 
814  24 

1297  25 
from plcopen import PLCOpenParser 
814  26 
from plcopen.structures import * 
27 
from types import * 

28 
import re 

29 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

30 
# Dictionary associating PLCOpen variable categories to the corresponding 
814  31 
# IEC 611313 variable categories 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

32 
varTypeNames = {"localVars" : "VAR", "tempVars" : "VAR_TEMP", "inputVars" : "VAR_INPUT", 
814  33 
"outputVars" : "VAR_OUTPUT", "inOutVars" : "VAR_IN_OUT", "externalVars" : "VAR_EXTERNAL", 
34 
"globalVars" : "VAR_GLOBAL", "accessVars" : "VAR_ACCESS"} 

35 

36 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

37 
# Dictionary associating PLCOpen POU categories to the corresponding 
814  38 
# IEC 611313 POU categories 
39 
pouTypeNames = {"function" : "FUNCTION", "functionBlock" : "FUNCTION_BLOCK", "program" : "PROGRAM"} 

40 

41 

42 
errorVarTypes = { 

43 
"VAR_INPUT": "var_input", 

44 
"VAR_OUTPUT": "var_output", 

45 
"VAR_INOUT": "var_inout", 

46 
} 

47 

48 
# Helper function for reindenting text 

49 
def ReIndentText(text, nb_spaces): 

50 
compute = "" 

51 
lines = text.splitlines() 

52 
if len(lines) > 0: 

53 
line_num = 0 

54 
while line_num < len(lines) and len(lines[line_num].strip()) == 0: 

55 
line_num += 1 

56 
if line_num < len(lines): 

57 
spaces = 0 

58 
while lines[line_num][spaces] == " ": 

59 
spaces += 1 

60 
indent = "" 

61 
for i in xrange(spaces, nb_spaces): 

62 
indent += " " 

63 
for line in lines: 

64 
if line != "": 

65 
compute += "%s%s\n"%(indent, line) 

66 
else: 

67 
compute += "\n" 

68 
return compute 

69 

70 
def SortInstances(a, b): 

71 
ax, ay = int(a.getx()), int(a.gety()) 

72 
bx, by = int(b.getx()), int(b.gety()) 

73 
if abs(ay  by) < 10: 

74 
return cmp(ax, bx) 

75 
else: 

76 
return cmp(ay, by) 

77 

1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

78 
# Helper for emulate join on element list 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

79 
def JoinList(separator, mylist): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

80 
if len(mylist) > 0 : 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

81 
return reduce(lambda x, y: x + separator + y, mylist) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

82 
else : 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

83 
return mylist 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

84 

814  85 
# 
86 
# Specific exception for PLC generating errors 

87 
# 

88 

89 

90 
class PLCGenException(Exception): 

91 
pass 

92 

93 

94 
# 

95 
# Generator of PLC program 

96 
# 

97 

98 

99 
class ProgramGenerator: 

100 

101 
# Create a new PCL program generator 

102 
def __init__(self, controler, project, errors, warnings): 

103 
# Keep reference of the controler and project 

104 
self.Controler = controler 

105 
self.Project = project 

106 
# Reset the internal variables used to generate PLC programs 

107 
self.Program = [] 

108 
self.DatatypeComputed = {} 

109 
self.PouComputed = {} 

110 
self.Errors = errors 

111 
self.Warnings = warnings 

112 

113 
# Compute value according to type given 

114 
def ComputeValue(self, value, var_type): 

115 
base_type = self.Controler.GetBaseType(var_type) 

1032
c4989e53f9c3
Fix bug defining string initial value using quotes
Laurent Bessard
parents:
893
diff
changeset

116 
if base_type == "STRING" and not value.startswith("'") and not value.endswith("'"): 
814  117 
return "'%s'"%value 
1032
c4989e53f9c3
Fix bug defining string initial value using quotes
Laurent Bessard
parents:
893
diff
changeset

118 
elif base_type == "WSTRING" and not value.startswith('"') and not value.endswith('"'): 
814  119 
return "\"%s\""%value 
120 
return value 

121 

122 
# Generate a data type from its name 

123 
def GenerateDataType(self, datatype_name): 

124 
# Verify that data type hasn't been generated yet 

125 
if not self.DatatypeComputed.get(datatype_name, True): 

126 
# If not mark data type as computed 

127 
self.DatatypeComputed[datatype_name] = True 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

128 

814  129 
# Getting datatype model from project 
130 
datatype = self.Project.getdataType(datatype_name) 

131 
tagname = self.Controler.ComputeDataTypeName(datatype.getname()) 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

132 
datatype_def = [(" ", ()), 
814  133 
(datatype.getname(), (tagname, "name")), 
134 
(" : ", ())] 

135 
basetype_content = datatype.baseType.getcontent() 

1297  136 
basetype_content_type = basetype_content.getLocalTag() 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

137 
# Data type derived directly from a user defined type 
1297  138 
if basetype_content_type == "derived": 
139 
basetype_name = basetype_content.getname() 

814  140 
self.GenerateDataType(basetype_name) 
141 
datatype_def += [(basetype_name, (tagname, "base"))] 

142 
# Data type is a subrange 

1297  143 
elif basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]: 
144 
base_type = basetype_content.baseType.getcontent() 

145 
base_type_type = base_type.getLocalTag() 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

146 
# Subrange derived directly from a user defined type 
1297  147 
if base_type_type == "derived": 
148 
basetype_name = base_type_type.getname() 

814  149 
self.GenerateDataType(basetype_name) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

150 
# Subrange derived directly from an elementary type 
814  151 
else: 
1297  152 
basetype_name = base_type_type 
153 
min_value = basetype_content.range.getlower() 

154 
max_value = basetype_content.range.getupper() 

814  155 
datatype_def += [(basetype_name, (tagname, "base")), 
156 
(" (", ()), 

157 
("%s"%min_value, (tagname, "lower")), 

158 
("..", ()), 

159 
("%s"%max_value, (tagname, "upper")), 

160 
(")",())] 

161 
# Data type is an enumerated type 

1297  162 
elif basetype_content_type == "enum": 
814  163 
values = [[(value.getname(), (tagname, "value", i))] 
1297  164 
for i, value in enumerate( 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

165 
basetype_content.xpath("ppx:values/ppx:value", 
1297  166 
namespaces=PLCOpenParser.NSMAP))] 
814  167 
datatype_def += [("(", ())] 
168 
datatype_def += JoinList([(", ", ())], values) 

169 
datatype_def += [(")", ())] 

170 
# Data type is an array 

1297  171 
elif basetype_content_type == "array": 
172 
base_type = basetype_content.baseType.getcontent() 

173 
base_type_type = base_type.getLocalTag() 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

174 
# Array derived directly from a user defined type 
1297  175 
if base_type_type == "derived": 
176 
basetype_name = base_type.getname() 

814  177 
self.GenerateDataType(basetype_name) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

178 
# Array derived directly from an elementary type 
814  179 
else: 
1297  180 
basetype_name = base_type_type.upper() 
814  181 
dimensions = [[("%s"%dimension.getlower(), (tagname, "range", i, "lower")), 
182 
("..", ()), 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

183 
("%s"%dimension.getupper(), (tagname, "range", i, "upper"))] 
1297  184 
for i, dimension in enumerate(basetype_content.getdimension())] 
814  185 
datatype_def += [("ARRAY [", ())] 
186 
datatype_def += JoinList([(",", ())], dimensions) 

187 
datatype_def += [("] OF " , ()), 

188 
(basetype_name, (tagname, "base"))] 

189 
# Data type is a structure 

1297  190 
elif basetype_content_type == "struct": 
814  191 
elements = [] 
1297  192 
for i, element in enumerate(basetype_content.getvariable()): 
814  193 
element_type = element.type.getcontent() 
1297  194 
element_type_type = element_type.getLocalTag() 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

195 
# Structure element derived directly from a user defined type 
1297  196 
if element_type_type == "derived": 
197 
elementtype_name = element_type.getname() 

814  198 
self.GenerateDataType(elementtype_name) 
1297  199 
elif element_type_type == "array": 
200 
base_type = element_type.baseType.getcontent() 

201 
base_type_type = base_type.getLocalTag() 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

202 
# Array derived directly from a user defined type 
1297  203 
if base_type_type == "derived": 
204 
basetype_name = base_type.getname() 

864
bf4f7f0801b9
Adding support for direct array declaration in structure element declaration
Laurent Bessard
parents:
854
diff
changeset

205 
self.GenerateDataType(basetype_name) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

206 
# Array derived directly from an elementary type 
864
bf4f7f0801b9
Adding support for direct array declaration in structure element declaration
Laurent Bessard
parents:
854
diff
changeset

207 
else: 
1297  208 
basetype_name = base_type_type.upper() 
864
bf4f7f0801b9
Adding support for direct array declaration in structure element declaration
Laurent Bessard
parents:
854
diff
changeset

209 
dimensions = ["%s..%s" % (dimension.getlower(), dimension.getupper()) 
1297  210 
for dimension in element_type.getdimension()] 
864
bf4f7f0801b9
Adding support for direct array declaration in structure element declaration
Laurent Bessard
parents:
854
diff
changeset

211 
elementtype_name = "ARRAY [%s] OF %s" % (",".join(dimensions), basetype_name) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

212 
# Structure element derived directly from an elementary type 
814  213 
else: 
1297  214 
elementtype_name = element_type_type.upper() 
814  215 
element_text = [("\n ", ()), 
216 
(element.getname(), (tagname, "struct", i, "name")), 

217 
(" : ", ()), 

218 
(elementtype_name, (tagname, "struct", i, "type"))] 

219 
if element.initialValue is not None: 

220 
element_text.extend([(" := ", ()), 

221 
(self.ComputeValue(element.initialValue.getvalue(), elementtype_name), (tagname, "struct", i, "initial value"))]) 

222 
element_text.append((";", ())) 

223 
elements.append(element_text) 

224 
datatype_def += [("STRUCT", ())] 

225 
datatype_def += JoinList([("", ())], elements) 

226 
datatype_def += [("\n END_STRUCT", ())] 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

227 
# Data type derived directly from a elementary type 
814  228 
else: 
1297  229 
datatype_def += [(basetype_content_type.upper(), (tagname, "base"))] 
814  230 
# Data type has an initial value 
231 
if datatype.initialValue is not None: 

232 
datatype_def += [(" := ", ()), 

233 
(self.ComputeValue(datatype.initialValue.getvalue(), datatype_name), (tagname, "initial value"))] 

234 
datatype_def += [(";\n", ())] 

235 
self.Program += datatype_def 

236 

237 
# Generate a POU from its name 

238 
def GeneratePouProgram(self, pou_name): 

239 
# Verify that POU hasn't been generated yet 

240 
if not self.PouComputed.get(pou_name, True): 

241 
# If not mark POU as computed 

242 
self.PouComputed[pou_name] = True 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

243 

814  244 
# Getting POU model from project 
245 
pou = self.Project.getpou(pou_name) 

246 
pou_type = pou.getpouType() 

247 
# Verify that POU type exists 

248 
if pouTypeNames.has_key(pou_type): 

249 
# Create a POU program generator 

250 
pou_program = PouProgramGenerator(self, pou.getname(), pouTypeNames[pou_type], self.Errors, self.Warnings) 

251 
program = pou_program.GenerateProgram(pou) 

252 
self.Program += program 

253 
else: 

254 
raise PLCGenException, _("Undefined pou type \"%s\"")%pou_type 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

255 

814  256 
# Generate a POU defined and used in text 
257 
def GeneratePouProgramInText(self, text): 

258 
for pou_name in self.PouComputed.keys(): 

259 
model = re.compile("(?:^[^09^AZ])%s(?:$[^09^AZ])"%pou_name.upper()) 

260 
if model.search(text) is not None: 

261 
self.GeneratePouProgram(pou_name) 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

262 

814  263 
# Generate a configuration from its model 
264 
def GenerateConfiguration(self, configuration): 

265 
tagname = self.Controler.ComputeConfigurationName(configuration.getname()) 

266 
config = [("\nCONFIGURATION ", ()), 

267 
(configuration.getname(), (tagname, "name")), 

268 
("\n", ())] 

269 
var_number = 0 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

270 

883
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

271 
varlists = [(varlist, varlist.getvariable()[:]) for varlist in configuration.getglobalVars()] 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

272 

883
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

273 
extra_variables = self.Controler.GetConfigurationExtraVariables() 
1315
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

274 
extra_global_vars = None 
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

275 
if len(extra_variables) > 0 and len(varlists) == 0: 
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

276 
extra_global_vars = PLCOpenParser.CreateElement("globalVars", "interface") 
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

277 
configuration.setglobalVars([extra_global_vars]) 
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

278 
varlists = [(extra_global_vars, [])] 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

279 

1315
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

280 
for variable in extra_variables: 
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

281 
varlists[1][0].appendvariable(variable) 
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

282 
varlists[1][1].append(variable) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

283 

814  284 
# Generate any global variable in configuration 
883
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

285 
for varlist, varlist_variables in varlists: 
814  286 
variable_type = errorVarTypes.get("VAR_GLOBAL", "var_local") 
287 
# Generate variable block with modifier 

288 
config += [(" VAR_GLOBAL", ())] 

289 
if varlist.getconstant(): 

290 
config += [(" CONSTANT", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "constant"))] 

291 
elif varlist.getretain(): 

292 
config += [(" RETAIN", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "retain"))] 

293 
elif varlist.getnonretain(): 

294 
config += [(" NON_RETAIN", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "non_retain"))] 

295 
config += [("\n", ())] 

296 
# Generate any variable of this block 

883
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

297 
for var in varlist_variables: 
814  298 
vartype_content = var.gettype().getcontent() 
1297  299 
if vartype_content.getLocalTag() == "derived": 
300 
var_type = vartype_content.getname() 

814  301 
self.GenerateDataType(var_type) 
302 
else: 

303 
var_type = var.gettypeAsText() 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

304 

814  305 
config += [(" ", ()), 
306 
(var.getname(), (tagname, variable_type, var_number, "name")), 

307 
(" ", ())] 

308 
# Generate variable address if exists 

309 
address = var.getaddress() 

310 
if address: 

311 
config += [("AT ", ()), 

312 
(address, (tagname, variable_type, var_number, "location")), 

313 
(" ", ())] 

314 
config += [(": ", ()), 

315 
(var.gettypeAsText(), (tagname, variable_type, var_number, "type"))] 

316 
# Generate variable initial value if exists 

317 
initial = var.getinitialValue() 

1315
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

318 
if initial is not None: 
814  319 
config += [(" := ", ()), 
320 
(self.ComputeValue(initial.getvalue(), var_type), (tagname, variable_type, var_number, "initial value"))] 

321 
config += [(";\n", ())] 

322 
var_number += 1 

323 
config += [(" END_VAR\n", ())] 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

324 

1315
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

325 
if extra_global_vars is not None: 
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

326 
configuration.remove(extra_global_vars) 
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

327 
else: 
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

328 
for variable in extra_variables: 
1358
fe7770a30527
Fixed bug when building project with configuration extra variables
Laurent Bessard
parents:
1322
diff
changeset

329 
varlists[1][0].remove(variable) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

330 

814  331 
# Generate any resource in the configuration 
332 
for resource in configuration.getresource(): 

333 
config += self.GenerateResource(resource, configuration.getname()) 

334 
config += [("END_CONFIGURATION\n", ())] 

335 
return config 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

336 

814  337 
# Generate a resource from its model 
338 
def GenerateResource(self, resource, config_name): 

339 
tagname = self.Controler.ComputeConfigurationResourceName(config_name, resource.getname()) 

340 
resrce = [("\n RESOURCE ", ()), 

341 
(resource.getname(), (tagname, "name")), 

342 
(" ON PLC\n", ())] 

343 
var_number = 0 

344 
# Generate any global variable in configuration 

345 
for varlist in resource.getglobalVars(): 

346 
variable_type = errorVarTypes.get("VAR_GLOBAL", "var_local") 

347 
# Generate variable block with modifier 

348 
resrce += [(" VAR_GLOBAL", ())] 

349 
if varlist.getconstant(): 

350 
resrce += [(" CONSTANT", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "constant"))] 

351 
elif varlist.getretain(): 

352 
resrce += [(" RETAIN", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "retain"))] 

353 
elif varlist.getnonretain(): 

354 
resrce += [(" NON_RETAIN", (tagname, variable_type, (var_number, var_number + len(varlist.getvariable())), "non_retain"))] 

355 
resrce += [("\n", ())] 

356 
# Generate any variable of this block 

357 
for var in varlist.getvariable(): 

358 
vartype_content = var.gettype().getcontent() 

1297  359 
if vartype_content.getLocalTag() == "derived": 
360 
var_type = vartype_content.getname() 

814  361 
self.GenerateDataType(var_type) 
362 
else: 

363 
var_type = var.gettypeAsText() 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

364 

814  365 
resrce += [(" ", ()), 
366 
(var.getname(), (tagname, variable_type, var_number, "name")), 

367 
(" ", ())] 

368 
address = var.getaddress() 

369 
# Generate variable address if exists 

370 
if address: 

371 
resrce += [("AT ", ()), 

372 
(address, (tagname, variable_type, var_number, "location")), 

373 
(" ", ())] 

374 
resrce += [(": ", ()), 

375 
(var.gettypeAsText(), (tagname, variable_type, var_number, "type"))] 

376 
# Generate variable initial value if exists 

377 
initial = var.getinitialValue() 

1315
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

378 
if initial is not None: 
814  379 
resrce += [(" := ", ()), 
380 
(self.ComputeValue(initial.getvalue(), var_type), (tagname, variable_type, var_number, "initial value"))] 

381 
resrce += [(";\n", ())] 

382 
var_number += 1 

383 
resrce += [(" END_VAR\n", ())] 

384 
# Generate any task in the resource 

385 
tasks = resource.gettask() 

386 
task_number = 0 

387 
for task in tasks: 

388 
# Task declaration 

389 
resrce += [(" TASK ", ()), 

390 
(task.getname(), (tagname, "task", task_number, "name")), 

391 
("(", ())] 

392 
args = [] 

393 
single = task.getsingle() 

394 
# Single argument if exists 

1315
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

395 
if single is not None: 
1420
71b1545d746f
Enable overloading of task triggerring source cell editor (SINGLE) in resource editor. PLCGenerator now generates MULTI keywork instead of SINGLE when task's activation is surroundes with square brackets
Edouard Tisserant
parents:
1418
diff
changeset

396 
if single[0]=='[' and single[1]==']' : 
71b1545d746f
Enable overloading of task triggerring source cell editor (SINGLE) in resource editor. PLCGenerator now generates MULTI keywork instead of SINGLE when task's activation is surroundes with square brackets
Edouard Tisserant
parents:
1418
diff
changeset

397 
SNGLKW = "MULTI" 
71b1545d746f
Enable overloading of task triggerring source cell editor (SINGLE) in resource editor. PLCGenerator now generates MULTI keywork instead of SINGLE when task's activation is surroundes with square brackets
Edouard Tisserant
parents:
1418
diff
changeset

398 
else: 
71b1545d746f
Enable overloading of task triggerring source cell editor (SINGLE) in resource editor. PLCGenerator now generates MULTI keywork instead of SINGLE when task's activation is surroundes with square brackets
Edouard Tisserant
parents:
1418
diff
changeset

399 
SNGLKW = "SINGLE" 
71b1545d746f
Enable overloading of task triggerring source cell editor (SINGLE) in resource editor. PLCGenerator now generates MULTI keywork instead of SINGLE when task's activation is surroundes with square brackets
Edouard Tisserant
parents:
1418
diff
changeset

400 
resrce += [(SNGLKW + " := ", ()), 
814  401 
(single, (tagname, "task", task_number, "single")), 
402 
(",", ())] 

403 
# Interval argument if exists 

404 
interval = task.getinterval() 

1315
ff14a66bbd12
Fixed Beremiz for working with new xmlclass support using lxml
Laurent Bessard
parents:
1310
diff
changeset

405 
if interval is not None: 
814  406 
resrce += [("INTERVAL := ", ()), 
407 
(interval, (tagname, "task", task_number, "interval")), 

408 
(",", ())] 

409 
## resrce += [("INTERVAL := t#", ())] 

410 
## if interval.hour != 0: 

411 
## resrce += [("%dh"%interval.hour, (tagname, "task", task_number, "interval", "hour"))] 

412 
## if interval.minute != 0: 

413 
## resrce += [("%dm"%interval.minute, (tagname, "task", task_number, "interval", "minute"))] 

414 
## if interval.second != 0: 

415 
## resrce += [("%ds"%interval.second, (tagname, "task", task_number, "interval", "second"))] 

416 
## if interval.microsecond != 0: 

417 
## resrce += [("%dms"%(interval.microsecond / 1000), (tagname, "task", task_number, "interval", "millisecond"))] 

418 
## resrce += [(",", ())] 

419 
# Priority argument 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

420 
resrce += [("PRIORITY := ", ()), 
814  421 
("%d"%task.getpriority(), (tagname, "task", task_number, "priority")), 
422 
(");\n", ())] 

423 
task_number += 1 

424 
instance_number = 0 

425 
# Generate any program assign to each task 

426 
for task in tasks: 

427 
for instance in task.getpouInstance(): 

428 
resrce += [(" PROGRAM ", ()), 

429 
(instance.getname(), (tagname, "instance", instance_number, "name")), 

430 
(" WITH ", ()), 

431 
(task.getname(), (tagname, "instance", instance_number, "task")), 

432 
(" : ", ()), 

433 
(instance.gettypeName(), (tagname, "instance", instance_number, "type")), 

434 
(";\n", ())] 

435 
instance_number += 1 

436 
# Generate any program assign to no task 

437 
for instance in resource.getpouInstance(): 

438 
resrce += [(" PROGRAM ", ()), 

439 
(instance.getname(), (tagname, "instance", instance_number, "name")), 

440 
(" : ", ()), 

441 
(instance.gettypeName(), (tagname, "instance", instance_number, "type")), 

442 
(";\n", ())] 

443 
instance_number += 1 

444 
resrce += [(" END_RESOURCE\n", ())] 

445 
return resrce 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

446 

814  447 
# Generate the entire program for current project 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

448 
def GenerateProgram(self): 
814  449 
# Find all data types defined 
450 
for datatype in self.Project.getdataTypes(): 

451 
self.DatatypeComputed[datatype.getname()] = False 

452 
# Find all data types defined 

453 
for pou in self.Project.getpous(): 

454 
self.PouComputed[pou.getname()] = False 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

455 
# Generate data type declaration structure if there is at least one data 
814  456 
# type defined 
457 
if len(self.DatatypeComputed) > 0: 

458 
self.Program += [("TYPE\n", ())] 

459 
# Generate every data types defined 

460 
for datatype_name in self.DatatypeComputed.keys(): 

461 
self.GenerateDataType(datatype_name) 

462 
self.Program += [("END_TYPE\n\n", ())] 

463 
# Generate every POUs defined 

464 
for pou_name in self.PouComputed.keys(): 

465 
self.GeneratePouProgram(pou_name) 

466 
# Generate every configurations defined 

467 
for config in self.Project.getconfigurations(): 

468 
self.Program += self.GenerateConfiguration(config) 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

469 

814  470 
# Return generated program 
471 
def GetGeneratedProgram(self): 

472 
return self.Program 

473 

474 

475 
# 

476 
# Generator of POU programs 

477 
# 

478 

1297  479 
[ConnectorClass, ContinuationClass, ActionBlockClass] = [ 
480 
PLCOpenParser.GetElementClass(instance_name, "commonObjects") 

481 
for instance_name in ["connector", "continuation", "actionBlock"]] 

482 
[InVariableClass, InOutVariableClass, OutVariableClass, BlockClass] = [ 

483 
PLCOpenParser.GetElementClass(instance_name, "fbdObjects") 

484 
for instance_name in ["inVariable", "inOutVariable", "outVariable", "block"]] 

485 
[ContactClass, CoilClass, LeftPowerRailClass, RightPowerRailClass] = [ 

486 
PLCOpenParser.GetElementClass(instance_name, "ldObjects") 

487 
for instance_name in ["contact", "coil", "leftPowerRail", "rightPowerRail"]] 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

488 
[StepClass, TransitionClass, JumpStepClass, 
1297  489 
SelectionConvergenceClass, SelectionDivergenceClass, 
490 
SimultaneousConvergenceClass, SimultaneousDivergenceClass] = [ 

491 
PLCOpenParser.GetElementClass(instance_name, "sfcObjects") 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

492 
for instance_name in ["step", "transition", "jumpStep", 
1297  493 
"selectionConvergence", "selectionDivergence", 
494 
"simultaneousConvergence", "simultaneousDivergence"]] 

495 
TransitionObjClass = PLCOpenParser.GetElementClass("transition", "transitions") 

496 
ActionObjClass = PLCOpenParser.GetElementClass("action", "actions") 

814  497 

498 
class PouProgramGenerator: 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

499 

814  500 
# Create a new POU program generator 
501 
def __init__(self, parent, name, type, errors, warnings): 

502 
# Keep Reference to the parent generator 

503 
self.ParentGenerator = parent 

504 
self.Name = name 

505 
self.Type = type 

506 
self.TagName = self.ParentGenerator.Controler.ComputePouName(name) 

507 
self.CurrentIndent = " " 

508 
self.ReturnType = None 

509 
self.Interface = [] 

510 
self.InitialSteps = [] 

511 
self.ComputedBlocks = {} 

512 
self.ComputedConnectors = {} 

513 
self.ConnectionTypes = {} 

514 
self.RelatedConnections = [] 

515 
self.SFCNetworks = {"Steps":{}, "Transitions":{}, "Actions":{}} 

516 
self.SFCComputedBlocks = [] 

517 
self.ActionNumber = 0 

518 
self.Program = [] 

519 
self.Errors = errors 

520 
self.Warnings = warnings 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

521 

814  522 
def GetBlockType(self, type, inputs=None): 
523 
return self.ParentGenerator.Controler.GetBlockType(type, inputs) 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

524 

814  525 
def IndentLeft(self): 
526 
if len(self.CurrentIndent) >= 2: 

527 
self.CurrentIndent = self.CurrentIndent[:2] 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

528 

814  529 
def IndentRight(self): 
530 
self.CurrentIndent += " " 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

531 

814  532 
# Generator of unique ID for inline actions 
533 
def GetActionNumber(self): 

534 
self.ActionNumber += 1 

535 
return self.ActionNumber 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

536 

814  537 
# Test if a variable has already been defined 
538 
def IsAlreadyDefined(self, name): 

539 
for list_type, option, located, vars in self.Interface: 

540 
for var_type, var_name, var_address, var_initial in vars: 

541 
if name == var_name: 

542 
return True 

543 
return False 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

544 

814  545 
# Return the type of a variable defined in interface 
546 
def GetVariableType(self, name): 

547 
parts = name.split('.') 

548 
current_type = None 

549 
if len(parts) > 0: 

550 
name = parts.pop(0) 

551 
for list_type, option, located, vars in self.Interface: 

552 
for var_type, var_name, var_address, var_initial in vars: 

553 
if name == var_name: 

554 
current_type = var_type 

555 
break 

556 
while current_type is not None and len(parts) > 0: 

883
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

557 
blocktype = self.ParentGenerator.Controler.GetBlockType(current_type) 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

558 
if blocktype is not None: 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

559 
name = parts.pop(0) 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

560 
current_type = None 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

561 
for var_name, var_type, var_modifier in blocktype["inputs"] + blocktype["outputs"]: 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

562 
if var_name == name: 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

563 
current_type = var_type 
814  564 
break 
883
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

565 
else: 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

566 
tagname = self.ParentGenerator.Controler.ComputeDataTypeName(current_type) 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

567 
infos = self.ParentGenerator.Controler.GetDataTypeInfos(tagname) 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

568 
if infos is not None and infos["type"] == "Structure": 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

569 
name = parts.pop(0) 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

570 
current_type = None 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

571 
for element in infos["elements"]: 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

572 
if element["Name"] == name: 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

573 
current_type = element["Type"] 
235a9ec83b95
Adding support for defining specific global variables for ConfTreeNodes
Laurent Bessard
parents:
864
diff
changeset

574 
break 
814  575 
return current_type 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

576 

814  577 
# Return connectors linked by a connection to the given connector 
578 
def GetConnectedConnector(self, connector, body): 

579 
links = connector.getconnections() 

1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

580 
if links is not None and len(links) == 1: 
814  581 
return self.GetLinkedConnector(links[0], body) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

582 
return None 
814  583 

584 
def GetLinkedConnector(self, link, body): 

585 
parameter = link.getformalParameter() 

586 
instance = body.getcontentInstance(link.getrefLocalId()) 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

587 
if isinstance(instance, (InVariableClass, InOutVariableClass, 
1297  588 
ContinuationClass, ContactClass, CoilClass)): 
814  589 
return instance.connectionPointOut 
1297  590 
elif isinstance(instance, BlockClass): 
814  591 
outputvariables = instance.outputVariables.getvariable() 
592 
if len(outputvariables) == 1: 

593 
return outputvariables[0].connectionPointOut 

594 
elif parameter: 

595 
for variable in outputvariables: 

596 
if variable.getformalParameter() == parameter: 

597 
return variable.connectionPointOut 

598 
else: 

599 
point = link.getposition()[1] 

600 
for variable in outputvariables: 

601 
relposition = variable.connectionPointOut.getrelPositionXY() 

602 
blockposition = instance.getposition() 

603 
if point.x == blockposition.x + relposition[0] and point.y == blockposition.y + relposition[1]: 

604 
return variable.connectionPointOut 

1297  605 
elif isinstance(instance, LeftPowerRailClass): 
814  606 
outputconnections = instance.getconnectionPointOut() 
607 
if len(outputconnections) == 1: 

608 
return outputconnections[0] 

609 
else: 

610 
point = link.getposition()[1] 

611 
for outputconnection in outputconnections: 

612 
relposition = outputconnection.getrelPositionXY() 

613 
powerrailposition = instance.getposition() 

614 
if point.x == powerrailposition.x + relposition[0] and point.y == powerrailposition.y + relposition[1]: 

615 
return outputconnection 

616 
return None 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

617 

814  618 
def ExtractRelatedConnections(self, connection): 
619 
for i, related in enumerate(self.RelatedConnections): 

620 
if connection in related: 

621 
return self.RelatedConnections.pop(i) 

622 
return [connection] 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

623 

814  624 
def ComputeInterface(self, pou): 
625 
interface = pou.getinterface() 

626 
if interface is not None: 

627 
body = pou.getbody() 

628 
if isinstance(body, ListType): 

629 
body = body[0] 

630 
body_content = body.getcontent() 

1297  631 
body_type = body_content.getLocalTag() 
814  632 
if self.Type == "FUNCTION": 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

633 
returntype_content = interface.getreturnType()[0] 
1297  634 
returntype_content_type = returntype_content.getLocalTag() 
635 
if returntype_content_type == "derived": 

636 
self.ReturnType = returntype_content.getname() 

637 
else: 

638 
self.ReturnType = returntype_content_type.upper() 

814  639 
for varlist in interface.getcontent(): 
640 
variables = [] 

641 
located = [] 

1297  642 
varlist_type = varlist.getLocalTag() 
643 
for var in varlist.getvariable(): 

814  644 
vartype_content = var.gettype().getcontent() 
1297  645 
if vartype_content.getLocalTag() == "derived": 
646 
var_type = vartype_content.getname() 

814  647 
blocktype = self.GetBlockType(var_type) 
648 
if blocktype is not None: 

649 
self.ParentGenerator.GeneratePouProgram(var_type) 

1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

650 
variables.append((var_type, var.getname(), None, None)) 
814  651 
else: 
652 
self.ParentGenerator.GenerateDataType(var_type) 

653 
initial = var.getinitialValue() 

1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

654 
if initial is not None: 
814  655 
initial_value = initial.getvalue() 
656 
else: 

657 
initial_value = None 

658 
address = var.getaddress() 

659 
if address is not None: 

1297  660 
located.append((vartype_content.getname(), var.getname(), address, initial_value)) 
814  661 
else: 
1297  662 
variables.append((vartype_content.getname(), var.getname(), None, initial_value)) 
814  663 
else: 
664 
var_type = var.gettypeAsText() 

665 
initial = var.getinitialValue() 

1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

666 
if initial is not None: 
814  667 
initial_value = initial.getvalue() 
668 
else: 

669 
initial_value = None 

670 
address = var.getaddress() 

671 
if address is not None: 

672 
located.append((var_type, var.getname(), address, initial_value)) 

673 
else: 

674 
variables.append((var_type, var.getname(), None, initial_value)) 

1297  675 
if varlist.getconstant(): 
814  676 
option = "CONSTANT" 
1297  677 
elif varlist.getretain(): 
814  678 
option = "RETAIN" 
1297  679 
elif varlist.getnonretain(): 
814  680 
option = "NON_RETAIN" 
681 
else: 

682 
option = None 

683 
if len(variables) > 0: 

1297  684 
self.Interface.append((varTypeNames[varlist_type], option, False, variables)) 
814  685 
if len(located) > 0: 
1297  686 
self.Interface.append((varTypeNames[varlist_type], option, True, located)) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

687 

1181
21e6db77eb29
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1134
diff
changeset

688 
LITERAL_TYPES = { 
21e6db77eb29
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1134
diff
changeset

689 
"T": "TIME", 
21e6db77eb29
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1134
diff
changeset

690 
"D": "DATE", 
21e6db77eb29
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1134
diff
changeset

691 
"TOD": "TIME_OF_DAY", 
21e6db77eb29
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1134
diff
changeset

692 
"DT": "DATE_AND_TIME", 
1183
a01618805821
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1181
diff
changeset

693 
"2": None, 
a01618805821
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1181
diff
changeset

694 
"8": None, 
a01618805821
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1181
diff
changeset

695 
"16": None, 
1181
21e6db77eb29
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1134
diff
changeset

696 
} 
814  697 
def ComputeConnectionTypes(self, pou): 
698 
body = pou.getbody() 

699 
if isinstance(body, ListType): 

700 
body = body[0] 

701 
body_content = body.getcontent() 

1297  702 
body_type = body_content.getLocalTag() 
814  703 
if body_type in ["FBD", "LD", "SFC"]: 
704 
undefined_blocks = [] 

705 
for instance in body.getcontentInstances(): 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

706 
if isinstance(instance, (InVariableClass, OutVariableClass, 
1297  707 
InOutVariableClass)): 
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1315
diff
changeset

708 
expression = instance.getexpression() 
814  709 
var_type = self.GetVariableType(expression) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

710 
if (isinstance(pou, TransitionObjClass) 
1297  711 
and expression == pou.getname()): 
822
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

712 
var_type = "BOOL" 
1297  713 
elif (not isinstance(pou, (TransitionObjClass, ActionObjClass)) and 
822
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

714 
pou.getpouType() == "function" and expression == pou.getname()): 
814  715 
returntype_content = pou.interface.getreturnType().getcontent() 
1297  716 
returntype_content_type = returntype_content.getLocalTag() 
717 
if returntype_content_type == "derived": 

718 
var_type = returntype_content.getname() 

814  719 
else: 
1297  720 
var_type = returntype_content_type.upper() 
814  721 
elif var_type is None: 
722 
parts = expression.split("#") 

723 
if len(parts) > 1: 

1181
21e6db77eb29
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1134
diff
changeset

724 
literal_prefix = parts[0].upper() 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

725 
var_type = self.LITERAL_TYPES.get(literal_prefix, 
1181
21e6db77eb29
Fixed bug in PLC code generated with binary, octal and hexadecimal literals
Laurent Bessard
parents:
1134
diff
changeset

726 
literal_prefix) 
814  727 
elif expression.startswith("'"): 
728 
var_type = "STRING" 

729 
elif expression.startswith('"'): 

730 
var_type = "WSTRING" 

731 
if var_type is not None: 

1297  732 
if isinstance(instance, (InVariableClass, InOutVariableClass)): 
814  733 
for connection in self.ExtractRelatedConnections(instance.connectionPointOut): 
734 
self.ConnectionTypes[connection] = var_type 

1297  735 
if isinstance(instance, (OutVariableClass, InOutVariableClass)): 
814  736 
self.ConnectionTypes[instance.connectionPointIn] = var_type 
737 
connected = self.GetConnectedConnector(instance.connectionPointIn, body) 

1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

738 
if connected is not None and not self.ConnectionTypes.has_key(connected): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

739 
for related in self.ExtractRelatedConnections(connected): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

740 
self.ConnectionTypes[related] = var_type 
1297  741 
elif isinstance(instance, (ContactClass, CoilClass)): 
814  742 
for connection in self.ExtractRelatedConnections(instance.connectionPointOut): 
743 
self.ConnectionTypes[connection] = "BOOL" 

744 
self.ConnectionTypes[instance.connectionPointIn] = "BOOL" 

1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

745 
for link in instance.connectionPointIn.getconnections(): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

746 
connected = self.GetLinkedConnector(link, body) 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

747 
if connected is not None and not self.ConnectionTypes.has_key(connected): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

748 
for related in self.ExtractRelatedConnections(connected): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

749 
self.ConnectionTypes[related] = "BOOL" 
1297  750 
elif isinstance(instance, LeftPowerRailClass): 
814  751 
for connection in instance.getconnectionPointOut(): 
752 
for related in self.ExtractRelatedConnections(connection): 

753 
self.ConnectionTypes[related] = "BOOL" 

1297  754 
elif isinstance(instance, RightPowerRailClass): 
814  755 
for connection in instance.getconnectionPointIn(): 
756 
self.ConnectionTypes[connection] = "BOOL" 

1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

757 
for link in connection.getconnections(): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

758 
connected = self.GetLinkedConnector(link, body) 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

759 
if connected is not None and not self.ConnectionTypes.has_key(connected): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

760 
for related in self.ExtractRelatedConnections(connected): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

761 
self.ConnectionTypes[related] = "BOOL" 
1297  762 
elif isinstance(instance, TransitionClass): 
763 
content = instance.getconditionContent() 

764 
if content["type"] == "connection": 

1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

765 
self.ConnectionTypes[content["value"]] = "BOOL" 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

766 
for link in content["value"].getconnections(): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

767 
connected = self.GetLinkedConnector(link, body) 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

768 
if connected is not None and not self.ConnectionTypes.has_key(connected): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

769 
for related in self.ExtractRelatedConnections(connected): 
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

770 
self.ConnectionTypes[related] = "BOOL" 
1297  771 
elif isinstance(instance, ContinuationClass): 
814  772 
name = instance.getname() 
773 
connector = None 

774 
var_type = "ANY" 

775 
for element in body.getcontentInstances(): 

1297  776 
if isinstance(element, ConnectorClass) and element.getname() == name: 
814  777 
if connector is not None: 
1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

778 
msg = _("More than one connector found corresponding to \"{a1}\" continuation in \"{a2}\" POU").format(a1 = name, a2 = self.Name) 
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

779 
raise PLCGenException, msg 
814  780 
connector = element 
781 
if connector is not None: 

782 
undefined = [instance.connectionPointOut, connector.connectionPointIn] 

783 
connected = self.GetConnectedConnector(connector.connectionPointIn, body) 

1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

784 
if connected is not None: 
814  785 
undefined.append(connected) 
786 
related = [] 

787 
for connection in undefined: 

788 
if self.ConnectionTypes.has_key(connection): 

789 
var_type = self.ConnectionTypes[connection] 

790 
else: 

791 
related.extend(self.ExtractRelatedConnections(connection)) 

792 
if var_type.startswith("ANY") and len(related) > 0: 

793 
self.RelatedConnections.append(related) 

794 
else: 

795 
for connection in related: 

796 
self.ConnectionTypes[connection] = var_type 

797 
else: 

1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

798 
msg = _("No connector found corresponding to \"{a1}\" continuation in \"{a2}\" POU").format(a1 = name, a2 = self.Name) 
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

799 
raise PLCGenException, msg 
1297  800 
elif isinstance(instance, BlockClass): 
814  801 
block_infos = self.GetBlockType(instance.gettypeName(), "undefined") 
802 
if block_infos is not None: 

803 
self.ComputeBlockInputTypes(instance, block_infos, body) 

804 
else: 

805 
for variable in instance.inputVariables.getvariable(): 

806 
connected = self.GetConnectedConnector(variable.connectionPointIn, body) 

807 
if connected is not None: 

808 
var_type = self.ConnectionTypes.get(connected, None) 

809 
if var_type is not None: 

810 
self.ConnectionTypes[variable.connectionPointIn] = var_type 

811 
else: 

812 
related = self.ExtractRelatedConnections(connected) 

813 
related.append(variable.connectionPointIn) 

814 
self.RelatedConnections.append(related) 

815 
undefined_blocks.append(instance) 

816 
for instance in undefined_blocks: 

817 
block_infos = self.GetBlockType(instance.gettypeName(), tuple([self.ConnectionTypes.get(variable.connectionPointIn, "ANY") for variable in instance.inputVariables.getvariable() if variable.getformalParameter() != "EN"])) 

818 
if block_infos is not None: 

819 
self.ComputeBlockInputTypes(instance, block_infos, body) 

820 
else: 

821 
raise PLCGenException, _("No informations found for \"%s\" block")%(instance.gettypeName()) 

822
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

822 
if body_type == "SFC": 
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

823 
previous_tagname = self.TagName 
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

824 
for action in pou.getactionList(): 
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

825 
self.TagName = self.ParentGenerator.Controler.ComputePouActionName(self.Name, action.getname()) 
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

826 
self.ComputeConnectionTypes(action) 
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

827 
for transition in pou.gettransitionList(): 
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

828 
self.TagName = self.ParentGenerator.Controler.ComputePouTransitionName(self.Name, transition.getname()) 
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

829 
self.ComputeConnectionTypes(transition) 
050045c32d98
Fix bug in PLCGenerator connection types not computed for SFC actions and transitions body
laurent
parents:
814
diff
changeset

830 
self.TagName = previous_tagname 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

831 

814  832 
def ComputeBlockInputTypes(self, instance, block_infos, body): 
833 
undefined = {} 

834 
for variable in instance.outputVariables.getvariable(): 

835 
output_name = variable.getformalParameter() 

836 
if output_name == "ENO": 

837 
for connection in self.ExtractRelatedConnections(variable.connectionPointOut): 

838 
self.ConnectionTypes[connection] = "BOOL" 

839 
else: 

840 
for oname, otype, oqualifier in block_infos["outputs"]: 

841 
if output_name == oname: 

842 
if otype.startswith("ANY"): 

843 
if not undefined.has_key(otype): 

844 
undefined[otype] = [] 

845 
undefined[otype].append(variable.connectionPointOut) 

846 
elif not self.ConnectionTypes.has_key(variable.connectionPointOut): 

847 
for connection in self.ExtractRelatedConnections(variable.connectionPointOut): 

848 
self.ConnectionTypes[connection] = otype 

849 
for variable in instance.inputVariables.getvariable(): 

850 
input_name = variable.getformalParameter() 

851 
if input_name == "EN": 

852 
for connection in self.ExtractRelatedConnections(variable.connectionPointIn): 

853 
self.ConnectionTypes[connection] = "BOOL" 

854 
else: 

855 
for iname, itype, iqualifier in block_infos["inputs"]: 

856 
if input_name == iname: 

857 
connected = self.GetConnectedConnector(variable.connectionPointIn, body) 

858 
if itype.startswith("ANY"): 

859 
if not undefined.has_key(itype): 

860 
undefined[itype] = [] 

861 
undefined[itype].append(variable.connectionPointIn) 

1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

862 
if connected is not None: 
814  863 
undefined[itype].append(connected) 
864 
else: 

865 
self.ConnectionTypes[variable.connectionPointIn] = itype 

1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

866 
if connected is not None and not self.ConnectionTypes.has_key(connected): 
814  867 
for connection in self.ExtractRelatedConnections(connected): 
868 
self.ConnectionTypes[connection] = itype 

869 
for var_type, connections in undefined.items(): 

870 
related = [] 

871 
for connection in connections: 

854
c10f2092c43a
Fixing bug in PLCGenerator with user defined functions and standard overloaded function
Laurent Bessard
parents:
822
diff
changeset

872 
connection_type = self.ConnectionTypes.get(connection) 
c10f2092c43a
Fixing bug in PLCGenerator with user defined functions and standard overloaded function
Laurent Bessard
parents:
822
diff
changeset

873 
if connection_type and not connection_type.startswith("ANY"): 
c10f2092c43a
Fixing bug in PLCGenerator with user defined functions and standard overloaded function
Laurent Bessard
parents:
822
diff
changeset

874 
var_type = connection_type 
814  875 
else: 
876 
related.extend(self.ExtractRelatedConnections(connection)) 

877 
if var_type.startswith("ANY") and len(related) > 0: 

878 
self.RelatedConnections.append(related) 

879 
else: 

880 
for connection in related: 

881 
self.ConnectionTypes[connection] = var_type 

882 

883 
def ComputeProgram(self, pou): 

884 
body = pou.getbody() 

885 
if isinstance(body, ListType): 

886 
body = body[0] 

887 
body_content = body.getcontent() 

1297  888 
body_type = body_content.getLocalTag() 
814  889 
if body_type in ["IL","ST"]: 
1297  890 
text = body_content.getanyText() 
814  891 
self.ParentGenerator.GeneratePouProgramInText(text.upper()) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

892 
self.Program = [(ReIndentText(text, len(self.CurrentIndent)), 
814  893 
(self.TagName, "body", len(self.CurrentIndent)))] 
894 
elif body_type == "SFC": 

895 
self.IndentRight() 

896 
for instance in body.getcontentInstances(): 

1297  897 
if isinstance(instance, StepClass): 
814  898 
self.GenerateSFCStep(instance, pou) 
1297  899 
elif isinstance(instance, ActionBlockClass): 
814  900 
self.GenerateSFCStepActions(instance, pou) 
1297  901 
elif isinstance(instance, TransitionClass): 
814  902 
self.GenerateSFCTransition(instance, pou) 
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

903 
elif isinstance(instance, JumpStepClass): 
814  904 
self.GenerateSFCJump(instance, pou) 
905 
if len(self.InitialSteps) > 0 and len(self.SFCComputedBlocks) > 0: 

906 
action_name = "COMPUTE_FUNCTION_BLOCKS" 

907 
action_infos = {"qualifier" : "S", "content" : action_name} 

908 
self.SFCNetworks["Steps"][self.InitialSteps[0]]["actions"].append(action_infos) 

909 
self.SFCNetworks["Actions"][action_name] = (self.SFCComputedBlocks, ()) 

910 
self.Program = [] 

911 
self.IndentLeft() 

912 
for initialstep in self.InitialSteps: 

913 
self.ComputeSFCStep(initialstep) 

914 
else: 

915 
otherInstances = {"outVariables&coils" : [], "blocks" : [], "connectors" : []} 

916 
orderedInstances = [] 

917 
for instance in body.getcontentInstances(): 

1297  918 
if isinstance(instance, (OutVariableClass, InOutVariableClass, BlockClass)): 
814  919 
executionOrderId = instance.getexecutionOrderId() 
920 
if executionOrderId > 0: 

921 
orderedInstances.append((executionOrderId, instance)) 

1297  922 
elif isinstance(instance, (OutVariableClass, InOutVariableClass)): 
814  923 
otherInstances["outVariables&coils"].append(instance) 
1297  924 
elif isinstance(instance, BlockClass): 
814  925 
otherInstances["blocks"].append(instance) 
1297  926 
elif isinstance(instance, ConnectorClass): 
814  927 
otherInstances["connectors"].append(instance) 
1297  928 
elif isinstance(instance, CoilClass): 
814  929 
otherInstances["outVariables&coils"].append(instance) 
930 
orderedInstances.sort() 

931 
otherInstances["outVariables&coils"].sort(SortInstances) 

932 
otherInstances["blocks"].sort(SortInstances) 

933 
instances = [instance for (executionOrderId, instance) in orderedInstances] 

1048
b450202605ab
Fixed bug in program elements computation order in PLCGenerator
Laurent Bessard
parents:
1032
diff
changeset

934 
instances.extend(otherInstances["outVariables&coils"] + otherInstances["blocks"] + otherInstances["connectors"]) 
814  935 
for instance in instances: 
1297  936 
if isinstance(instance, (OutVariableClass, InOutVariableClass)): 
814  937 
connections = instance.connectionPointIn.getconnections() 
938 
if connections is not None: 

939 
expression = self.ComputeExpression(body, connections) 

1239
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

940 
if expression is not None: 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

941 
self.Program += [(self.CurrentIndent, ()), 
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1315
diff
changeset

942 
(instance.getexpression(), (self.TagName, "io_variable", instance.getlocalId(), "expression")), 
1239
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

943 
(" := ", ())] 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

944 
self.Program += expression 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

945 
self.Program += [(";\n", ())] 
1297  946 
elif isinstance(instance, BlockClass): 
814  947 
block_type = instance.gettypeName() 
948 
self.ParentGenerator.GeneratePouProgram(block_type) 

949 
block_infos = self.GetBlockType(block_type, tuple([self.ConnectionTypes.get(variable.connectionPointIn, "ANY") for variable in instance.inputVariables.getvariable() if variable.getformalParameter() != "EN"])) 

950 
if block_infos is None: 

951 
block_infos = self.GetBlockType(block_type) 

952 
if block_infos is None: 

1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

953 
raise PLCGenException, _("Undefined block type \"{a1}\" in \"{a2}\" POU").format(a1 = block_type, a2 = self.Name) 
1134
1c7a4ad86aa1
Fixed PLC code generator when interface of an already used POU has changed
Laurent Bessard
parents:
1048
diff
changeset

954 
try: 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

955 
self.GenerateBlock(instance, block_infos, body, None) 
1134
1c7a4ad86aa1
Fixed PLC code generator when interface of an already used POU has changed
Laurent Bessard
parents:
1048
diff
changeset

956 
except ValueError, e: 
1c7a4ad86aa1
Fixed PLC code generator when interface of an already used POU has changed
Laurent Bessard
parents:
1048
diff
changeset

957 
raise PLCGenException, e.message 
1297  958 
elif isinstance(instance, ConnectorClass): 
814  959 
connector = instance.getname() 
960 
if self.ComputedConnectors.get(connector, None): 

1239
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

961 
continue 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

962 
expression = self.ComputeExpression(body, instance.connectionPointIn.getconnections()) 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

963 
if expression is not None: 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

964 
self.ComputedConnectors[connector] = expression 
1297  965 
elif isinstance(instance, CoilClass): 
814  966 
connections = instance.connectionPointIn.getconnections() 
967 
if connections is not None: 

968 
coil_info = (self.TagName, "coil", instance.getlocalId()) 

1239
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

969 
expression = self.ComputeExpression(body, connections) 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

970 
if expression is not None: 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

971 
expression = self.ExtractModifier(instance, expression, coil_info) 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

972 
self.Program += [(self.CurrentIndent, ())] 
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1315
diff
changeset

973 
self.Program += [(instance.getvariable(), coil_info + ("reference",))] 
1239
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

974 
self.Program += [(" := ", ())] + expression + [(";\n", ())] 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

975 

814  976 
def FactorizePaths(self, paths): 
977 
same_paths = {} 

978 
uncomputed_index = range(len(paths)) 

979 
factorized_paths = [] 

980 
for num, path in enumerate(paths): 

981 
if type(path) == ListType: 

982 
if len(path) > 1: 

983 
str_path = str(path[1:]) 

984 
same_paths.setdefault(str_path, []) 

985 
same_paths[str_path].append((path[:1], num)) 

986 
else: 

987 
factorized_paths.append(path) 

988 
uncomputed_index.remove(num) 

989 
for same_path, elements in same_paths.items(): 

990 
if len(elements) > 1: 

991 
elements_paths = self.FactorizePaths([path for path, num in elements]) 

992 
if len(elements_paths) > 1: 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

993 
factorized_paths.append([tuple(elements_paths)] + eval(same_path)) 
814  994 
else: 
995 
factorized_paths.append(elements_paths + eval(same_path)) 

996 
for path, num in elements: 

997 
uncomputed_index.remove(num) 

998 
for num in uncomputed_index: 

999 
factorized_paths.append(paths[num]) 

1000 
factorized_paths.sort() 

1001 
return factorized_paths 

1002 

1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1003 
def GenerateBlock(self, block, block_infos, body, link, order=False, to_inout=False): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1004 
body_type = body.getcontent().getLocalTag() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1005 
name = block.getinstanceName() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1006 
type = block.gettypeName() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1007 
executionOrderId = block.getexecutionOrderId() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1008 
input_variables = block.inputVariables.getvariable() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1009 
output_variables = block.outputVariables.getvariable() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1010 
inout_variables = {} 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1011 
for input_variable in input_variables: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1012 
for output_variable in output_variables: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1013 
if input_variable.getformalParameter() == output_variable.getformalParameter(): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1014 
inout_variables[input_variable.getformalParameter()] = "" 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1015 
input_names = [input[0] for input in block_infos["inputs"]] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1016 
output_names = [output[0] for output in block_infos["outputs"]] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1017 
if block_infos["type"] == "function": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1018 
if not self.ComputedBlocks.get(block, False) and not order: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1019 
self.ComputedBlocks[block] = True 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1020 
connected_vars = [] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1021 
if not block_infos["extensible"]: 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1022 
input_connected = dict([("EN", None)] + 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1023 
[(input_name, None) for input_name in input_names]) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1024 
for variable in input_variables: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1025 
parameter = variable.getformalParameter() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1026 
if input_connected.has_key(parameter): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1027 
input_connected[parameter] = variable 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1028 
if input_connected["EN"] is None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1029 
input_connected.pop("EN") 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1030 
input_parameters = input_names 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1031 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1032 
input_parameters = ["EN"] + input_names 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1033 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1034 
input_connected = dict([(variable.getformalParameter(), variable) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1035 
for variable in input_variables]) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1036 
input_parameters = [variable.getformalParameter() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1037 
for variable in input_variables] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1038 
one_input_connected = False 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1039 
all_input_connected = True 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1040 
for i, parameter in enumerate(input_parameters): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1041 
variable = input_connected.get(parameter) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1042 
if variable is not None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1043 
input_info = (self.TagName, "block", block.getlocalId(), "input", i) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1044 
connections = variable.connectionPointIn.getconnections() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1045 
if connections is not None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1046 
if parameter != "EN": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1047 
one_input_connected = True 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1048 
if inout_variables.has_key(parameter): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1049 
expression = self.ComputeExpression(body, connections, executionOrderId > 0, True) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1050 
if expression is not None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1051 
inout_variables[parameter] = value 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1052 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1053 
expression = self.ComputeExpression(body, connections, executionOrderId > 0) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1054 
if expression is not None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1055 
connected_vars.append(([(parameter, input_info), (" := ", ())], 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1056 
self.ExtractModifier(variable, expression, input_info))) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1057 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1058 
all_input_connected = False 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1059 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1060 
all_input_connected = False 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1061 
if len(output_variables) > 1 or not all_input_connected: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1062 
vars = [name + value for name, value in connected_vars] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1063 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1064 
vars = [value for name, value in connected_vars] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1065 
if one_input_connected: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1066 
for i, variable in enumerate(output_variables): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1067 
parameter = variable.getformalParameter() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1068 
if not inout_variables.has_key(parameter) and parameter in output_names + ["", "ENO"]: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1069 
if variable.getformalParameter() == "": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1070 
variable_name = "%s%d"%(type, block.getlocalId()) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1071 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1072 
variable_name = "%s%d_%s"%(type, block.getlocalId(), parameter) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1073 
if self.Interface[1][0] != "VAR" or self.Interface[1][1] is not None or self.Interface[1][2]: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1074 
self.Interface.append(("VAR", None, False, [])) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1075 
if variable.connectionPointOut in self.ConnectionTypes: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1076 
self.Interface[1][3].append((self.ConnectionTypes[variable.connectionPointOut], variable_name, None, None)) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1077 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1078 
self.Interface[1][3].append(("ANY", variable_name, None, None)) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1079 
if len(output_variables) > 1 and parameter not in ["", "OUT"]: 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1080 
vars.append([(parameter, (self.TagName, "block", block.getlocalId(), "output", i)), 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1081 
(" => %s"%variable_name, ())]) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1082 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1083 
output_info = (self.TagName, "block", block.getlocalId(), "output", i) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1084 
output_name = variable_name 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1085 
self.Program += [(self.CurrentIndent, ()), 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1086 
(output_name, output_info), 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1087 
(" := ", ()), 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1088 
(type, (self.TagName, "block", block.getlocalId(), "type")), 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1089 
("(", ())] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1090 
self.Program += JoinList([(", ", ())], vars) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1091 
self.Program += [(");\n", ())] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1092 
else: 
1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1093 
msg = _("\"{a1}\" function cancelled in \"{a2}\" POU: No input connected").format(a1 = type, a2 = self.TagName.split("::")[1]) 
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1094 
self.Warnings.append(msg) 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1095 
elif block_infos["type"] == "functionBlock": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1096 
if not self.ComputedBlocks.get(block, False) and not order: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1097 
self.ComputedBlocks[block] = True 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1098 
vars = [] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1099 
offset_idx = 0 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1100 
for variable in input_variables: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1101 
parameter = variable.getformalParameter() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1102 
if parameter in input_names or parameter == "EN": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1103 
if parameter == "EN": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1104 
input_idx = 0 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1105 
offset_idx = 1 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1106 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1107 
input_idx = offset_idx + input_names.index(parameter) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1108 
input_info = (self.TagName, "block", block.getlocalId(), "input", input_idx) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1109 
connections = variable.connectionPointIn.getconnections() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1110 
if connections is not None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1111 
expression = self.ComputeExpression(body, connections, executionOrderId > 0, inout_variables.has_key(parameter)) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1112 
if expression is not None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1113 
vars.append([(parameter, input_info), 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1114 
(" := ", ())] + self.ExtractModifier(variable, expression, input_info)) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1115 
self.Program += [(self.CurrentIndent, ()), 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1116 
(name, (self.TagName, "block", block.getlocalId(), "name")), 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1117 
("(", ())] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1118 
self.Program += JoinList([(", ", ())], vars) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1119 
self.Program += [(");\n", ())] 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1120 

1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1121 
if link is not None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1122 
connectionPoint = link.getposition()[1] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1123 
output_parameter = link.getformalParameter() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1124 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1125 
connectionPoint = None 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1126 
output_parameter = None 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1127 

1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1128 
output_variable = None 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1129 
output_idx = 0 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1130 
if output_parameter is not None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1131 
if output_parameter in output_names or output_parameter == "ENO": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1132 
for variable in output_variables: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1133 
if variable.getformalParameter() == output_parameter: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1134 
output_variable = variable 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1135 
if output_parameter != "ENO": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1136 
output_idx = output_names.index(output_parameter) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1137 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1138 
for i, variable in enumerate(output_variables): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1139 
blockPointx, blockPointy = variable.connectionPointOut.getrelPositionXY() 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1140 
if (connectionPoint is None or 
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1141 
block.getx() + blockPointx == connectionPoint.getx() and 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1142 
block.gety() + blockPointy == connectionPoint.gety()): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1143 
output_variable = variable 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1144 
output_parameter = variable.getformalParameter() 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1145 
output_idx = i 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1146 

1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1147 
if output_variable is not None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1148 
if block_infos["type"] == "function": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1149 
output_info = (self.TagName, "block", block.getlocalId(), "output", output_idx) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1150 
if inout_variables.has_key(output_parameter): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1151 
output_value = inout_variables[output_parameter] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1152 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1153 
if output_parameter == "": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1154 
output_name = "%s%d"%(type, block.getlocalId()) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1155 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1156 
output_name = "%s%d_%s"%(type, block.getlocalId(), output_parameter) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1157 
output_value = [(output_name, output_info)] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1158 
return self.ExtractModifier(output_variable, output_value, output_info) 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1159 

1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1160 
if block_infos["type"] == "functionBlock": 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1161 
output_info = (self.TagName, "block", block.getlocalId(), "output", output_idx) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1162 
output_name = self.ExtractModifier(output_variable, [("%s.%s"%(name, output_parameter), output_info)], output_info) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1163 
if to_inout: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1164 
variable_name = "%s_%s"%(name, output_parameter) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1165 
if not self.IsAlreadyDefined(variable_name): 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1166 
if self.Interface[1][0] != "VAR" or self.Interface[1][1] is not None or self.Interface[1][2]: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1167 
self.Interface.append(("VAR", None, False, [])) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1168 
if variable.connectionPointOut in self.ConnectionTypes: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1169 
self.Interface[1][3].append( 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1170 
(self.ConnectionTypes[output_variable.connectionPointOut], variable_name, None, None)) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1171 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1172 
self.Interface[1][3].append(("ANY", variable_name, None, None)) 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1173 
self.Program += [(self.CurrentIndent, ()), 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1174 
("%s := "%variable_name, ())] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1175 
self.Program += output_name 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1176 
self.Program += [(";\n", ())] 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1177 
return [(variable_name, ())] 
1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1178 
return output_name 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1179 
if link is not None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1180 
if output_parameter is None: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1181 
output_parameter = "" 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1182 
if name: 
1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1183 
blockname = "{a1}({a2})".format(a1 = name, a2 = type) 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1184 
else: 
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1185 
blockname = type 
1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1186 
msg = _("No output {a1} variable found in block {a2} in POU {a3}. Connection must be broken").\ 
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1187 
format(a1 = output_parameter, a2 = blockname, a3 = self.Name) 
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1188 
raise ValueError, msg 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1189 

814  1190 
def GeneratePaths(self, connections, body, order = False, to_inout = False): 
1191 
paths = [] 

1192 
for connection in connections: 

1193 
localId = connection.getrefLocalId() 

1194 
next = body.getcontentInstance(localId) 

1297  1195 
if isinstance(next, LeftPowerRailClass): 
814  1196 
paths.append(None) 
1297  1197 
elif isinstance(next, (InVariableClass, InOutVariableClass)): 
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1315
diff
changeset

1198 
paths.append(str([(next.getexpression(), (self.TagName, "io_variable", localId, "expression"))])) 
1297  1199 
elif isinstance(next, BlockClass): 
814  1200 
block_type = next.gettypeName() 
1201 
self.ParentGenerator.GeneratePouProgram(block_type) 

1202 
block_infos = self.GetBlockType(block_type, tuple([self.ConnectionTypes.get(variable.connectionPointIn, "ANY") for variable in next.inputVariables.getvariable() if variable.getformalParameter() != "EN"])) 

1203 
if block_infos is None: 

1204 
block_infos = self.GetBlockType(block_type) 

1205 
if block_infos is None: 

1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1206 
msg = _("Undefined block type \"{a1}\" in \"{a2}\" POU").format(a1 = block_type, a2 = self.Name) 
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1207 
raise PLCGenException, msg 
1134
1c7a4ad86aa1
Fixed PLC code generator when interface of an already used POU has changed
Laurent Bessard
parents:
1048
diff
changeset

1208 
try: 
1310
3d7fa2257b24
Removed obsolete process for customizing block code generated in extensions
Laurent Bessard
parents:
1298
diff
changeset

1209 
paths.append(str(self.GenerateBlock(next, block_infos, body, connection, order, to_inout))) 
1134
1c7a4ad86aa1
Fixed PLC code generator when interface of an already used POU has changed
Laurent Bessard
parents:
1048
diff
changeset

1210 
except ValueError, e: 
1c7a4ad86aa1
Fixed PLC code generator when interface of an already used POU has changed
Laurent Bessard
parents:
1048
diff
changeset

1211 
raise PLCGenException, e.message 
1297  1212 
elif isinstance(next, ContinuationClass): 
814  1213 
name = next.getname() 
1214 
computed_value = self.ComputedConnectors.get(name, None) 

1215 
if computed_value != None: 

1216 
paths.append(str(computed_value)) 

1217 
else: 

1218 
connector = None 

1219 
for instance in body.getcontentInstances(): 

1297  1220 
if isinstance(instance, ConnectorClass) and instance.getname() == name: 
814  1221 
if connector is not None: 
1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1222 
msg = _("More than one connector found corresponding to \"{a1}\" continuation in \"{a2}\" POU").format(a1 = name, a2 = self.Name) 
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1223 
raise PLCGenException, msg 
814  1224 
connector = instance 
1225 
if connector is not None: 

1226 
connections = connector.connectionPointIn.getconnections() 

1227 
if connections is not None: 

1228 
expression = self.ComputeExpression(body, connections, order) 

1239
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

1229 
if expression is not None: 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

1230 
self.ComputedConnectors[name] = expression 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

1231 
paths.append(str(expression)) 
814  1232 
else: 
1581
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1233 
msg = _("No connector found corresponding to \"{a1}\" continuation in \"{a2}\" POU").format(a1 = name, a2 = self.Name) 
2295fdc5c271
fix translation strings with multiple parameters
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1571
diff
changeset

1234 
raise PLCGenException, msg 
1297  1235 
elif isinstance(next, ContactClass): 
814  1236 
contact_info = (self.TagName, "contact", next.getlocalId()) 
1322
0a9227f743b3
Fixed xmlclass for working with included files, adding support for SimpleType elements and solving ambiguity in extension class when different elements share the same name and parent name
Laurent Bessard
parents:
1315
diff
changeset

1237 
variable = str(self.ExtractModifier(next, [(next.getvariable(), contact_info + ("reference",))], contact_info)) 
814  1238 
result = self.GeneratePaths(next.connectionPointIn.getconnections(), body, order) 
1239 
if len(result) > 1: 

1240 
factorized_paths = self.FactorizePaths(result) 

1241 
if len(factorized_paths) > 1: 

1242 
paths.append([variable, tuple(factorized_paths)]) 

1243 
else: 

1244 
paths.append([variable] + factorized_paths) 

1245 
elif type(result[0]) == ListType: 

1246 
paths.append([variable] + result[0]) 

1247 
elif result[0] is not None: 

1248 
paths.append([variable, result[0]]) 

1249 
else: 

1250 
paths.append(variable) 

1297  1251 
elif isinstance(next, CoilClass): 
814  1252 
paths.append(str(self.GeneratePaths(next.connectionPointIn.getconnections(), body, order))) 
1253 
return paths 

1254 

1255 
def ComputePaths(self, paths, first = False): 

1256 
if type(paths) == TupleType: 

1257 
if None in paths: 

1258 
return [("TRUE", ())] 

1259 
else: 

1260 
vars = [self.ComputePaths(path) for path in paths] 

1261 
if first: 

1262 
return JoinList([(" OR ", ())], vars) 

1263 
else: 

1264 
return [("(", ())] + JoinList([(" OR ", ())], vars) + [(")", ())] 

1265 
elif type(paths) == ListType: 

1266 
vars = [self.ComputePaths(path) for path in paths] 

1267 
return JoinList([(" AND ", ())], vars) 

1268 
elif paths is None: 

1269 
return [("TRUE", ())] 

1270 
else: 

1271 
return eval(paths) 

1272 

1273 
def ComputeExpression(self, body, connections, order = False, to_inout = False): 

1274 
paths = self.GeneratePaths(connections, body, order, to_inout) 

1239
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

1275 
if len(paths) == 0: 
d1f6ea56555d
Fixed bug when generating ST code and connection is broken in POU using graphical language
Laurent Bessard
parents:
1183
diff
changeset

1276 
return None 
814  1277 
if len(paths) > 1: 
1278 
factorized_paths = self.FactorizePaths(paths) 

1279 
if len(factorized_paths) > 1: 

1280 
paths = tuple(factorized_paths) 

1281 
else: 

1282 
paths = factorized_paths[0] 

1283 
else: 

1284 
paths = paths[0] 

1285 
return self.ComputePaths(paths, True) 

1286 

1287 
def ExtractModifier(self, variable, expression, var_info): 

1288 
if variable.getnegated(): 

1289 
return [("NOT(", var_info + ("negated",))] + expression + [(")", ())] 

1290 
else: 

1291 
storage = variable.getstorage() 

1292 
if storage in ["set", "reset"]: 

1293 
self.Program += [(self.CurrentIndent + "IF ", var_info + (storage,))] + expression 

1294 
self.Program += [(" THEN\n ", ())] 

1295 
if storage == "set": 

1296 
return [("TRUE; (*set*)\n" + self.CurrentIndent + "END_IF", ())] 

1297 
else: 

1298 
return [("FALSE; (*reset*)\n" + self.CurrentIndent + "END_IF", ())] 

1299 
edge = variable.getedge() 

1300 
if edge == "rising": 

1301 
return self.AddTrigger("R_TRIG", expression, var_info + ("rising",)) 

1302 
elif edge == "falling": 

1303 
return self.AddTrigger("F_TRIG", expression, var_info + ("falling",)) 

1304 
return expression 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1305 

814  1306 
def AddTrigger(self, edge, expression, var_info): 
1307 
if self.Interface[1][0] != "VAR" or self.Interface[1][1] is not None or self.Interface[1][2]: 

1308 
self.Interface.append(("VAR", None, False, [])) 

1309 
i = 1 

1310 
name = "%s%d"%(edge, i) 

1311 
while self.IsAlreadyDefined(name): 

1312 
i += 1 

1313 
name = "%s%d"%(edge, i) 

1314 
self.Interface[1][3].append((edge, name, None, None)) 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1315 
self.Program += [(self.CurrentIndent, ()), (name, var_info), ("(CLK := ", ())] 
814  1316 
self.Program += expression 
1317 
self.Program += [(");\n", ())] 

1318 
return [("%s.Q"%name, var_info)] 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1319 

814  1320 
def ExtractDivergenceInput(self, divergence, pou): 
1321 
connectionPointIn = divergence.getconnectionPointIn() 

1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

1322 
if connectionPointIn is not None: 
814  1323 
connections = connectionPointIn.getconnections() 
1324 
if connections is not None and len(connections) == 1: 

1325 
instanceLocalId = connections[0].getrefLocalId() 

1326 
body = pou.getbody() 

1327 
if isinstance(body, ListType): 

1328 
body = body[0] 

1329 
return body.getcontentInstance(instanceLocalId) 

1330 
return None 

1331 

1332 
def ExtractConvergenceInputs(self, convergence, pou): 

1333 
instances = [] 

1334 
for connectionPointIn in convergence.getconnectionPointIn(): 

1335 
connections = connectionPointIn.getconnections() 

1336 
if connections is not None and len(connections) == 1: 

1337 
instanceLocalId = connections[0].getrefLocalId() 

1338 
body = pou.getbody() 

1339 
if isinstance(body, ListType): 

1340 
body = body[0] 

1341 
instances.append(body.getcontentInstance(instanceLocalId)) 

1342 
return instances 

1343 

1344 
def GenerateSFCStep(self, step, pou): 

1345 
step_name = step.getname() 

1346 
if step_name not in self.SFCNetworks["Steps"].keys(): 

1347 
if step.getinitialStep(): 

1348 
self.InitialSteps.append(step_name) 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1349 
step_infos = {"id" : step.getlocalId(), 
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1350 
"initial" : step.getinitialStep(), 
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1351 
"transitions" : [], 
814  1352 
"actions" : []} 
889
ac18acb6917f
Fix bug when using feedback loop in SFC program instead of jump
Laurent Bessard
parents:
883
diff
changeset

1353 
self.SFCNetworks["Steps"][step_name] = step_infos 
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

1354 
if step.connectionPointIn is not None: 
814  1355 
instances = [] 
1356 
connections = step.connectionPointIn.getconnections() 

1357 
if connections is not None and len(connections) == 1: 

1358 
instanceLocalId = connections[0].getrefLocalId() 

1359 
body = pou.getbody() 

1360 
if isinstance(body, ListType): 

1361 
body = body[0] 

1362 
instance = body.getcontentInstance(instanceLocalId) 

1297  1363 
if isinstance(instance, TransitionClass): 
814  1364 
instances.append(instance) 
1297  1365 
elif isinstance(instance, SelectionConvergenceClass): 
814  1366 
instances.extend(self.ExtractConvergenceInputs(instance, pou)) 
1297  1367 
elif isinstance(instance, SimultaneousDivergenceClass): 
814  1368 
transition = self.ExtractDivergenceInput(instance, pou) 
1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

1369 
if transition is not None: 
1297  1370 
if isinstance(transition, TransitionClass): 
814  1371 
instances.append(transition) 
1297  1372 
elif isinstance(transition, SelectionConvergenceClass): 
814  1373 
instances.extend(self.ExtractConvergenceInputs(transition, pou)) 
1374 
for instance in instances: 

1375 
self.GenerateSFCTransition(instance, pou) 

1376 
if instance in self.SFCNetworks["Transitions"].keys(): 

1377 
target_info = (self.TagName, "transition", instance.getlocalId(), "to", step_infos["id"]) 

1378 
self.SFCNetworks["Transitions"][instance]["to"].append([(step_name, target_info)]) 

1418
c97dc5281419
Fixed declaration and ST code gen for IEC function that return derivated types
Edouard Tisserant
parents:
1358
diff
changeset

1379 

814  1380 
def GenerateSFCJump(self, jump, pou): 
1381 
jump_target = jump.gettargetName() 

1298
f034fb2b1aab
Fixed SFC block edition and SFC to SFC_textual code generating
Laurent Bessard
parents:
1297
diff
changeset

1382 
if jump.connectionPointIn is not None: 
814  1383 
instances = [] 
1384 
connections = jump.connectionPointIn.getconnections() 

1385 
if connections is not None and len(connections) == 1: 

1386 
instanceLocalId = connections[0].getrefLocalId() 

1387 
body = pou.getbody() 

1388 
if isinstance(body, ListType): 

1389 
body = body[0] 

1390 
instance = body.getcontentInstance(instanceLocalId) 

1297  1391 
if isinstance(instance, TransitionClass): 
814  1392 
instances.append(instance) 
1297  1393 
elif isinstance(instance, SelectionConvergenceClass): 
814  1394 
instances.extend(self.ExtractConvergenceInputs(instance, pou)) 
1297  1395 
elif isinstance(instance, SimultaneousDivergenceClass): 