def Usage(self):

print "Usage:"

print ""

print "Supported options:"

print "-h --help Print this help"

self.runtime_port = int(random.random() * 1000) + 61131

# launch local runtime

self.local_runtime = ProcessLogger(self.Log,

sys.executable,

Bpath("Beremiz_service.py"),

self.runtime_port,

-e - python extension (absolute path .py)

working_dir - directory where are stored PLC files

try:

opts, argv = getopt.getopt(sys.argv[1:], "i:p:n:x:t:a:w:c:e:h")

texts = {"value" : value}

for function, message in self.Tests:

if not function(value):

message.ShowModal()

message.Destroy()

return

# Call the confnode specific OnCTNSave method

result = self.OnCTNSave(from_project_path)

if not result:

# mark confnode as saved

self.ChangesToSave = False

BaseDesiredName = DesiredName

suffix = 1

while res in AllNames:

suffix += 1

# Get old path

if res < CurrentChannel: # Want to go down ?

res -= 1 # Test for n-1

if res < 0 :

return CurrentChannel # Can't go bellow 0, do nothing

else : # Want to go up ?

res += 1 # Test for n-1

new_name = event.GetLabel()

if new_name != "":

if not TestIdentifier(new_name):

elif new_name.upper() in IEC_KEYWORDS:

else:

item = event.GetItem()

old_name = self.ProjectTree.GetItemText(item)

self.Controler.SetProjectProperties(name = new_name)

elif item_infos["type"] == ITEM_DATATYPE:

if new_name.upper() in [name.upper() for name in self.Controler.GetProjectDataTypeNames() if name != old_name]:

abort = True

if not abort:

self.Controler.ChangeDataTypeName(old_name, new_name)

self.RefreshPageTitles()

elif item_infos["type"] == ITEM_POU:

if new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames() if name != old_name]:

abort = True

elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouVariableNames()]:

if messageDialog.ShowModal() == wx.ID_NO:

abort = True

messageDialog.Destroy()

pou_item = self.ProjectTree.GetItemParent(event.GetItem())

pou_name = self.ProjectTree.GetItemText(pou_item)

if new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames()]:

elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouVariableNames(pou_name) if name != old_name]:

else:

words = item_infos["tagname"].split("::")

self.Controler.ChangePouTransitionName(words[1], old_name, new_name)

pou_item = self.ProjectTree.GetItemParent(event.GetItem())

pou_name = self.ProjectTree.GetItemText(pou_item)

if new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames()]:

elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouVariableNames(pou_name) if name != old_name]:

else:

words = item_infos["tagname"].split("::")

self.Controler.ChangePouActionName(words[1], old_name, new_name)

self.RefreshPageTitles()

elif item_infos["type"] == ITEM_CONFIGURATION:

if new_name.upper() in [name.upper() for name in self.Controler.GetProjectConfigNames() if name != old_name]:

abort = True

elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames()]:

if messageDialog.ShowModal() == wx.ID_NO:

abort = True

messageDialog.Destroy()

elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouVariableNames()]:

if messageDialog.ShowModal() == wx.ID_NO:

abort = True

messageDialog.Destroy()

self.RefreshPageTitles()

elif item_infos["type"] == ITEM_RESOURCE:

if new_name.upper() in [name.upper() for name in self.Controler.GetProjectConfigNames()]:

abort = True

elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames()]:

if messageDialog.ShowModal() == wx.ID_NO:

abort = True

messageDialog.Destroy()

elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouVariableNames()]:

if messageDialog.ShowModal() == wx.ID_NO:

abort = True

messageDialog.Destroy()

if self.ProjectIsSaved():

return self.FileName

else:

return ""

# Change file path and save file name or create a default one if file path not defined

self.FilePath = filepath

if filepath == "":

self.LastNewIndex += 1

else:

self.FileName = os.path.splitext(os.path.basename(filepath))[0]

i = start_idx

while name is None or names.get(name.upper(), False):

i += 1

return name

blockname = instance.getinstanceName()

if blocktype_infos["type"] != "function" and blockname is not None:

if element_type == "function":

blockname = self.GenerateNewName(tagname,

blockname,

debug=debug)

exclude[blockname] = True

instance.setinstanceName(blockname)

indent += " "

for line in lines:

if line != "":

else:

compute += "\n"

return compute

def ComputeValue(self, value, var_type):

base_type = self.Controler.GetBaseType(var_type)

if base_type == "STRING" and not value.startswith("'") and not value.endswith("'"):

elif base_type == "WSTRING" and not value.startswith('"') and not value.endswith('"'):

return value

# Generate a data type from its name

max_value = basetype_content.range.getupper()

datatype_def += [(basetype_name, (tagname, "base")),

(" (", ()),

("..", ()),

(")",())]

# Data type is an enumerated type

elif basetype_content_type == "enum":

# Array derived directly from an elementary type

else:

basetype_name = base_type_type.upper()

("..", ()),

for i, dimension in enumerate(basetype_content.getdimension())]

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

datatype_def += JoinList([(",", ())], dimensions)

program = pou_program.GenerateProgram(pou)

self.Program += program

else:

# Generate a POU defined and used in text

def GeneratePouProgramInText(self, text):

for pou_name in self.PouComputed.keys():

if model.search(text) is not None:

self.GeneratePouProgram(pou_name)

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

# Priority argument

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

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

task_number += 1

instance_number = 0

if block_infos is not None:

self.ComputeBlockInputTypes(instance, block_infos, body)

else:

if body_type == "SFC":

previous_tagname = self.TagName

for action in pou.getactionList():

parameter = variable.getformalParameter()

if not inout_variables.has_key(parameter) and parameter in output_names + ["", "ENO"]:

if variable.getformalParameter() == "":

else:

if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] is not None or self.Interface[-1][2]:

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

if variable.connectionPointOut in self.ConnectionTypes:

self.Interface[-1][3].append(("ANY", variable_name, None, None))

if len(output_variables) > 1 and parameter not in ["", "OUT"]:

vars.append([(parameter, (self.TagName, "block", block.getlocalId(), "output", i)),

else:

output_info = (self.TagName, "block", block.getlocalId(), "output", i)

output_name = variable_name

output_value = inout_variables[output_parameter]

else:

if output_parameter == "":

else:

output_value = [(output_name, output_info)]

return self.ExtractModifier(output_variable, output_value, output_info)

if block_infos["type"] == "functionBlock":

output_info = (self.TagName, "block", block.getlocalId(), "output", output_idx)

if to_inout:

if not self.IsAlreadyDefined(variable_name):

if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] is not None or self.Interface[-1][2]:

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

else:

self.Interface[-1][3].append(("ANY", variable_name, None, None))

self.Program += [(self.CurrentIndent, ()),

self.Program += output_name

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

return [(variable_name, ())]

if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] is not None or self.Interface[-1][2]:

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

i = 1

while self.IsAlreadyDefined(name):

i += 1

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

self.Program += [(self.CurrentIndent, ()), (name, var_info), ("(CLK := ", ())]

self.Program += expression

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

def ExtractDivergenceInput(self, divergence, pou):

connectionPointIn = divergence.getconnectionPointIn()

if action["type"] == "reference":

self.GenerateSFCAction(action["value"], pou)

else:

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

(action["value"], (self.TagName, "action_block", action_infos["id"], "action", i, "inline")),

("\n", ())], ())

self.SFCNetworks["Transitions"][transition] = transition_infos

transitionValues = transition.getconditionContent()

if transitionValues["type"] == "inline":

(transitionValues["value"], (self.TagName, "transition", transition.getlocalId(), "inline")),

(";\n", ())]

elif transitionValues["type"] == "reference":

if connections is not None:

expression = self.ComputeExpression(transitionBody, connections)

if expression is not None:

self.SFCComputedBlocks += self.Program

self.Program = []

if not transition_infos.has_key("content"):

if connections is not None:

expression = self.ComputeExpression(body, connections)

if expression is not None:

self.SFCComputedBlocks += self.Program

self.Program = []

for step in steps:

(action_infos["indicator"], action_info + ("indicator",))]

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

self.IndentLeft()

for action in actions:

self.ComputeSFCAction(action)

for transition in step_infos["transitions"]:

def ComputeSFCAction(self, action_name):

if action_name in self.SFCNetworks["Actions"].keys():

action_content, action_info = self.SFCNetworks["Actions"].pop(action_name)

(action_name, action_info),

(":\n", ())]

self.Program += action_content

def ComputeSFCTransition(self, transition):

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

transition_infos = self.SFCNetworks["Transitions"].pop(transition)

if transition_infos["priority"] != None:

self.Program += [(" (PRIORITY := ", ()),

(")", ())]

self.Program += [(" FROM ", ())]

if len(transition_infos["from"]) > 1:

format(a1 = transition_infos["content"], a2 = self.Name)

raise PLCGenException, msg

self.Program += transition_infos["content"]

for [(step_name, step_infos)] in transition_infos["to"]:

self.ComputeSFCStep(step_name)

self.ComputeConnectionTypes(pou)

self.ComputeProgram(pou)

(self.Name, (self.TagName, "name"))]

if self.ReturnType is not None:

program += [(" : ", ()),

(self.ReturnType, (self.TagName, "return"))]

program += [("\n", ())]

if len(self.Interface) == 0:

if len(self.Program) == 0 :

var_number = 0

for list_type, option, located, variables in self.Interface:

variable_type = errorVarTypes.get(list_type, "var_local")

if option is not None:

program += [("\n", ())]

for var_type, var_name, var_address, var_initial in variables:

program += [(" ", ())]

program += [(" END_VAR\n", ())]

program += [("\n", ())]

program += self.Program

return program

def GenerateCurrentProgram(controler, project, errors, warnings):

# command line

def usage():

print "\nUsage of PLCOpenEditor.py :"

# Parse options given to PLCOpenEditor in command line

try:

def RefreshTitle(self):

name = _("PLCOpenEditor")

if self.Controler is not None:

else:

self.SetTitle(name)

message_text += "".join([_("warning: %s\n") % warning for warning in warnings])

if len(errors) > 0:

message_text += "".join([_("error: %s\n") % error for error in errors])

header, icon = _("Error"), wx.ICON_ERROR

else:

message_text += _("Program was successfully generated!")

else:

header, icon = _("Error"), wx.ICON_ERROR

message = wx.MessageDialog(self, message_text, header, wx.OK|icon)

message.ShowModal()

if filepath != "":

directory, filename = os.path.split(filepath)

else:

dialog = wx.FileDialog(self, _("Choose a file"), directory, filename, _("PLCOpen files (*.xml)|*.xml|All files|*.*"), wx.SAVE|wx.OVERWRITE_PROMPT)

if dialog.ShowModal() == wx.ID_OK:

filepath = dialog.GetPath()

if os.path.isdir(os.path.dirname(filepath)):

result = self.Controler.SaveXMLFile(filepath)

if not result:

else:

self._Refresh(TITLE, FILEMENU, PAGETITLES)

dialog.Destroy()

return path

def findSupportedOptions(self):

options =["-f", "-l", "-p"]

buildopt = ""

if len(self.Libraries)==0:

return [],[],()

self.GetIECProgramsAndVariables()

LocatedCCodeAndFlags=[]

Extras=[]

for lib in self.Libraries:

if len(warnings) > 0:

self.logger.write_warning(_("Warnings in ST/IL/SFC code generator :\n"))

for warning in warnings:

if len(errors) > 0:

# Failed !

return False

plc_file = open(self._getIECcodepath(), "w")

# Add ST Library from confnodes

def _Compile_ST_to_SoftPLC(self):

self.logger.write(_("Compiling IEC Program into C code...\n"))

buildpath = self._getBuildPath()

iec2c_cfg.getCmd(),

iec2c_cfg.getOptions(),

iec2c_cfg.getLibPath(),

f.close()

return False

# Now extract C files of stdout

# Keep track of generated C files for later use by self.CTNGenerate_C

self.PLCGeneratedCFiles = C_files

# compute CFLAGS for plc

return True

def GetBuilder(self):

for v in self._DbgVariablesList :

sz = DebugTypesSize.get(v["type"], 0)

variable_decl_array += [

{"EXT":"%(type)s_P_ENUM",

"IN":"%(type)s_P_ENUM",

"MEM":"%(type)s_O_ENUM",

"OUT":"%(type)s_O_ENUM",

"}"]

bofs += sz

debug_code = targets.GetCode("plc_debug.c") % {

"buffer_size":bofs,

"programs_declarations":

"extern_variables_declarations":"\n".join([

{"EXT":"extern __IEC_%(type)s_p %(C_path)s;",

"IN":"extern __IEC_%(type)s_p %(C_path)s;",

"MEM":"extern __IEC_%(type)s_p %(C_path)s;",

"OUT":"extern __IEC_%(type)s_p %(C_path)s;",

"VAR":"extern __IEC_%(type)s_t %(C_path)s;",

for v in self._VariablesList if v["C_path"].find('.')<0]),

"variable_decl_array": ",\n".join(variable_decl_array)

}

"int __init_%(s)s(int argc,char **argv);\n"+

"void __cleanup_%(s)s(void);\n"+

"void __retrieve_%(s)s(void);\n"+

"retrieve_calls":"\n ".join([

"publish_calls":"\n ".join([ #Call publish in reverse order

"init_calls":"\n ".join([

#"printf(\"%s\"); "%locstr + #for debug

"return res;}" for i,locstr in enumerate(locstrs)]),

"cleanup_calls":"\n ".join([

}

else:

plc_main_code = targets.GetCode("plc_main_head.c") % {

if IEC_Type in DebugTypesSize:

Idxs.append((Idx, IEC_Type, fvalue, IECPath))

else:

else:

for IECPathToPop in IECPathsToPop:

self.IECdebug_datas.pop(IECPathToPop)

try:

self._SetConnector(connectors.ConnectorFactory(uri, self))

except Exception, msg:

self.logger.write_error(traceback.format_exc())

# Did connection success ?

if self._connector is None:

# Oups.

else:

self.ShowMethod("_Connect", False)

self.ShowMethod("_Disconnect", True)

# Adding Beremiz confnode functions

text += "/* Beremiz confnode functions */\n"

text += self.CodeFile.initFunction.getanyText().strip()

text += " return 0;\n}\n\n"

text += self.CodeFile.cleanUpFunction.getanyText().strip()

text += "\n}\n\n"

text += self.CodeFile.retrieveFunction.getanyText().strip()

text += "\n}\n\n"

text += self.CodeFile.publishFunction.getanyText().strip()

text += "\n}\n\n"

cfile = open(Gen_Cfile_path,'w')

cfile.write(text)

cfile.close()

return [(Gen_Cfile_path, str(self.CExtension.getCFLAGS() + matiec_CFLAGS))],str(self.CExtension.getLDFLAGS()),True

"size": size,

"IEC_type": IECTypeConversion.get(typeinfos["name"]),

"var_name": "%s_%4.4x_%2.2x" % ("_".join(name.split()), index, subindex),

(index, subindex)))),

"description": "",

"children": []})

current_location = self.GetCurrentLocation()

# define a unique name for the generated C file

prefix = "_".join(map(str, current_location))

# Create a new copy of the model

slave = self.GetCurrentNodeCopy()

# allow access to local OD from Slave PLC

pointers = config_utils.LocalODPointers(locations, current_location, slave)

res = gen_cfile.GenerateFile(Gen_OD_path, slave, pointers)

if res :

raise Exception, res

if res :

raise Exception, res

return [(Gen_OD_path,local_canfestival_config.getCFLAGS(CanFestivalPath))],"",False

current_location = self.GetCurrentLocation()

# define a unique name for the generated C file

prefix = "_".join(map(str, current_location))

# Create a new copy of the model with DCF loaded with PDO mappings for desired location

try:

except config_utils.PDOmappingException, e:

raise Exception, e.message

# Do generate C file.

# Not a slave -> master

child_data = getattr(child, "CanFestivalNode")

# Apply sync setting

nodename,

child_data.getNodeId())

if child_data.getSync_TPDOs():

# initialize and declare node boot status variables for post_SlaveBootup lookup

SlaveIDs = child.GetSlaveIDs()

if len(SlaveIDs) == 0:

# define post_SlaveBootup lookup functions

format_dict["slavebootups"] += (

else:

format_dict["slavebootups"] += (

" check_and_start_node(d, nodeId);\n"+

"}\n")

# register previously declared func as post_SlaveBootup callback for that node

format_dict["slavebootup_register"] += (

format_dict["pre_op"] += (

"}\n")

format_dict["pre_op_register"] += (

else:

# Slave node

align = child_data.getSync_Align()

align_ratio=child_data.getSync_Align_Ratio()

if align > 0:

format_dict["post_sync"] += (

" align_tick(-1);\n"+

" }else{\n"+

" }\n"+

"}\n")

format_dict["post_sync_register"] += (

nodename,

child_data.getNodeId())

# Include generated OD headers

# Declare CAN channels according user filled config

nodename,

child.GetCanDevice(),

child_data.getCAN_Baudrate())

filename = paths.AbsNeighbourFile(__file__,"cf_runtime.c")

cf_main = open(filename).read() % format_dict

f = open(cf_main_path,'w')

f.write(cf_main)

f.close()

if nodeDCF != None and nodeDCF != '':

tmpnbparams = [i for i in nodeDCF[:4]]

tmpnbparams.reverse()

data = nodeDCF[4:] + data

# Build new DCF

variable_infos["nodeid"]

# Generate entry name

variable_infos["sizelocation"],

'_'.join(map(str,current_location)),

variable_infos["nodeid"])

if mapvariableidx < VariableStartIndex[variable_infos["pdotype"]] + 0x2000:

# Generate subentry name

if variable_infos["bit"] != None:

else:

# If entry have just been created, no subentry have to be added

if not new_index:

self.Manager.AddSubentriesToCurrent(mapvariableidx, 1, self.MasterNode)

self.MasterNode.SetEntry(current_idx + 0x200, subindex, value)

# Add variable to pointed variables

def GenerateConciseDCF(locations, current_location, nodelist, sync_TPDOs, nodename):

"""

Reset the reference result of config_utils test.

Use with caution. Be sure that config_utils

is currently working properly.

# Boolean that indicate if reference result must be redefined

reset = False

try:

masternode, pointedvariables = GenerateConciseDCF(locations, (0, 1), nodelist, True, "TestNode")

except ValueError, message:

sys.exit()

import pprint

# start the client from a Twisted endpoint

conn = connectWS(transport_factory)

return conn

AddToDoBeforeQuit = confnodesroot.AppFrame.AddToDoBeforeQuit

try :

return WampPLCObjectProxy()

except Exception, msg:

confnodesroot.logger.write_error(traceback.format_exc())

return None

if not isinstance(values, TupleType):

raise ValueError

except:

values = None

# Display message if data is invalid

if not isinstance(values, TupleType):

raise ValueError

except:

values = None

# Display message if data is invalid

try:

values = eval(data)

except:

values = None

if not isinstance(values, TupleType):

values = None

if values is not None:

if col != wx.NOT_FOUND and row != wx.NOT_FOUND:

if message is None:

if not location.startswith("%"):

if location[0].isdigit() and base_type != "BOOL":

elif location[0] not in LOCATIONDATATYPES:

elif base_type not in LOCATIONDATATYPES[location[0]]:

message = _("Incompatible size of data between \"{a1}\" and \"{a2}\"").\

format(a1 = location, a2 = variable_type)

elif var_name.upper() in [name.upper()

for name in self.ParentWindow.Controler.\

GetProjectPouNames(self.ParentWindow.Debug)]:

elif not var_name.upper() in [name.upper()

for name in self.ParentWindow.Controler.\

GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

self.ParentWindow.SaveValues()

self.ParentWindow.RefreshValues()

else:

if message is not None:

wx.CallAfter(self.ShowMessage, message)

for dimensions in dimension_strings:

result = DIMENSION_MODEL.match(dimensions)

if result is None:

break

bounds = result.groups()

if int(bounds[0]) >= int(bounds[1]):

break

dimensions_list.append(bounds)

def OnIpButton(self, event):

if self.LatestSelection is not None:

l = lambda col : self.getColumnText(self.LatestSelection,col)

self.EndModal(wx.ID_OK)

event.Skip()

self.LatestSelection = idx

svcname = self.getColumnText(idx, 0)

connect_type = self.getColumnText(idx, 1)

def GetURI(self):

return self.URI

if i == 0:

text += item

elif i == len(error) - 1:

else:

message = _("Form isn't complete. %s must be filled!") % text

elif not TestIdentifier(action_name):

message = _("\"%s\" is not a valid identifier!") % action_name

if i == 0:

text += item

elif i == len(error) - 1:

else:

message = _("Form isn't complete. %s must be filled!") % text

elif not TestIdentifier(pou_name):

message = _("\"%s\" is not a valid identifier!") % pou_name

if i == 0:

text += item

elif i == len(error) - 1:

else:

message = _("Form isn't complete. %s must be filled!") % text

elif not TestIdentifier(transition_name):

message = _("\"%s\" is not a valid identifier!") % transition_name

if i == 0:

text += item

elif i == len(error) - 1:

else:

dialog = wx.MessageDialog(self,

_("Form isn't complete. %s must be filled!") % text,

_("Error"), wx.OK|wx.ICON_ERROR)

if wx.Platform == '__WXMSW__':

import webbrowser

webbrowser.open(url)

wx.MessageBox("""Firefox browser not found.\nPlease point your browser at :\n%s""" % url)

except ImportError:

wx.MessageBox('Please point your browser at: %s' % url)

def open_win_pdf(readerexepath, pdffile, pagenum = None):

if pagenum != None :

else:

def open_lin_pdf(readerexepath, pdffile, pagenum = None):

if pagenum == None :

else:

def open_pdf(pdffile, pagenum = None):

if wx.Platform == '__WXMSW__' :

def open_lin_svg(svgexepath, svgfile):

""" Open Inkscape on Linux platform """

if os.path.isfile("/usr/bin/inkscape"):

def open_svg(svgfile):

""" Generic function to open SVG file """

first = True

for element_infos in elements:

if path:

else:

element_path = element_infos["name"]

if element_infos["type"] == "element":

flags |= wx.TOP

sizer.AddSizer(boxsizer, border=5, flag=flags)

staticbitmap = GenStaticBitmap(ID=-1, bitmapname=element_infos["name"],

pos=wx.Point(0, 0), size=wx.Size(24, 24), style=0)

boxsizer.AddWindow(staticbitmap, border=5, flag=wx.RIGHT)

statictext = wx.StaticText(self.ParamsEditor,

boxsizer.AddWindow(statictext, border=5,

flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT)

value = element_infos["value"]

staticbox = wx.StaticBox(self.ParamsEditor,

staticboxsizer = wx.StaticBoxSizer(staticbox, wx.VERTICAL)

sizer.AddSizer(staticboxsizer, border=5, flag=wx.GROW | wx.BOTTOM | wx.LEFT | wx.RIGHT)

self.GenerateSizerElements(staticboxsizer, element_infos["children"], element_path)

index = event.GetIndex()

if index >= len(values) or values[index].upper() != text.upper():

if text.upper() in [value.upper() for value in values]:

message.ShowModal()

message.Destroy()

event.Veto()

elif text.upper() in IEC_KEYWORDS:

message.ShowModal()

message.Destroy()

else:

if colname == "Name":

message = None

if not TestIdentifier(value):

elif value.upper() in IEC_KEYWORDS:

## elif value.upper() in self.PouNames:

## message = _("A pou with \"%s\" as name exists!")%value

elif value.upper() in [var["Name"].upper() for idx, var in enumerate(self.StructureElementsTable.GetData()) if idx != row]:

else:

self.RefreshTypeInfos()

wx.CallAfter(self.StructureElementsTable.ResetView, self.StructureElementsGrid)

for dimensions in self.ArrayDimensions.GetStrings():

result = DIMENSION_MODEL.match(dimensions)

if result is None:

message.ShowModal()

message.Destroy()

self.RefreshView()

return

bounds = result.groups()

if int(bounds[0]) >= int(bounds[1]):

message.ShowModal()

message.Destroy()

self.RefreshView()

if rung not in rungs:

rungs.append(rung)

if len(rungs) > 1:

element = self.FindElementById(instance["id"])

element_connectors = element.GetConnectors()

self.Rungs[rungs[0]].SelectElement(element)

if rung not in rungs:

rungs.append(rung)

if len(rungs) > 1:

element = self.FindElementById(instance["id"])

element_connectors = element.GetConnectors()

self.Rungs[rungs[0]].SelectElement(element)

self.TypeList = ""

blocktypes = self.Controler.GetBlockResource()

for blocktype in blocktypes:

def RefreshTaskList(self):

self.TaskList = ""

for row in xrange(self.TasksTable.GetNumberRows()):

def RefreshVariableList(self):

self.VariableList = ""

for variable in self.Controler.GetEditedResourceVariables(self.TagName):

def RefreshModel(self):

self.Controler.SetEditedResourceInfos(self.TagName, self.TasksTable.GetData(), self.InstancesTable.GetData())

re_texts = {}

re_texts["letter"] = "[A-Za-z]"

re_texts["digit"] = "[0-9]"

IDENTIFIER_MODEL = re.compile(re_texts["identifier"])

EXTENSIBLE_PARAMETER = re.compile("IN[1-9][0-9]*$")

HIGHLIGHT_TYPES = {

return

dialog.Destroy()

if blockname.upper() in [name.upper() for name in self.Controler.GetProjectPouNames(self.Debug)]:

elif blockname.upper() in [name.upper() for name in self.Controler.GetEditedElementVariables(self.TagName, self.Debug)]:

else:

self.Controler.AddEditedElementPouVar(self.TagName, values[0], blockname)

self.RefreshVariablePanel()

if var_name is None:

return

elif var_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames(self.Debug)]:

elif var_name.upper() in [name.upper() for name in self.Controler.GetEditedElementVariables(self.TagName, self.Debug)]:

else:

location = values[0]

if not location.startswith("%"):

if var_name is None:

return

elif var_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames(self.Debug)]:

else:

var_type = values[2]

if not var_name.upper() in [name.upper() for name in self.Controler.GetEditedElementVariables(self.TagName, self.Debug)]:

if var_name is None:

return

elif var_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames(self.Debug)]:

else:

if not var_name.upper() in [name.upper() for name in self.Controler.GetEditedElementVariables(self.TagName, self.Debug)]:

self.Controler.AddEditedElementPouExternalVar(self.TagName, values[2], var_name)

try:

values = eval(data)

except:

values = None

if not isinstance(values, TupleType):

values = None

if values is not None:

if values[1] == "debug":

elif values[1] in ["function", "functionBlock"]:

words = tagname.split("::")

if pou_name == values[0]:

elif pou_type == "function" and values[1] != "function":

message = _("Function Blocks can't be used in Functions!")

elif self.ParentWindow.Controler.PouIsUsedBy(pou_name, values[0], self.ParentWindow.Debug):

if values[1] != "function" and blockname == "":

blockname = self.ParentWindow.GenerateNewName(blocktype=values[0])

if blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

elif blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

else:

id = self.ParentWindow.GetNewId()

block = FBD_Block(self.ParentWindow, values[0], blockname, id, inputs = blockinputs)

if var_name is None:

return

elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

if location[1] == "Q":

var_class = OUTPUT

self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

else:

elif values[1] == "NamedConstant":

if pou_type == "program":

initval = values[0]

if var_name is None:

return

elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

var_class = INPUT

var_type = values[2]

self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

else:

elif values[1] == "Global":

var_name = values[0]

dlg = wx.TextEntryDialog(

if var_name is None:

return

elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

self.ParentWindow.Controler.AddEditedElementPouExternalVar(tagname, values[2], var_name)

self.ParentWindow.RefreshVariablePanel()

self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

self.ParentWindow.AddVariableBlock(x, y, scaling, INPUT, var_name, values[2])

else:

elif values[1] == "Constant":

self.ParentWindow.AddVariableBlock(x, y, scaling, INPUT, values[0], None)

elif values[3] == tagname:

blockname = block.GetName()

connectorname = element.GetName()

if blockname != "":

else:

if connectorname == "":

else:

elif isinstance(block, FBD_Variable):

elif isinstance(block, FBD_Connector):

connection = self.GetConnectorByName(block.GetName())

if connection is not None:

if len(connector.Wires) == 1:

iec_path = self.GetElementIECPath(connector.Wires[0][0])

elif isinstance(element, LD_Contact):

elif isinstance(element, SFC_Step):

elif isinstance(element, SFC_Transition):

connectors = element.GetConnectors()

previous_steps = self.GetPreviousSteps(connectors["inputs"])

next_steps = self.GetNextSteps(connectors["outputs"])

return iec_path

def GetWireModifier(self, wire):

def OnEditBlockMenu(self, event):

if self.SelectedElement is not None:

def OnAdjustBlockSizeMenu(self, event):

if self.SelectedElement is not None:

}.get(self.Controler.GetPouType(instance_type))

if pou_type is not None and instance_type in self.Controler.GetProjectPouNames(self.Debug):

self.ParentWindow.OpenDebugViewer(pou_type,

self.Controler.ComputePouName(instance_type))

else:

iec_path = self.GetElementIECPath(self.SelectedElement)

start = int(inputs[-1][0].replace("IN", ""))

for i in xrange(self.Extension - len(blocktype["inputs"])):

start += 1

comment = blocktype["comment"]

self.Description = _(comment) + blocktype.get("usage", "")

else:

if not words_found.get(word, False) and messages.find("msgid \"%s\"\nmsgstr \"\"" % word) == -1:

words_found[word] = True

messages_file.write('\n')

messages_file.write("msgstr \"\"\n")

code_file.close()

time_values.extend([int(seconds), int((seconds % 1) * 1000000)])

text = "T#"

if time_values[0] != 0:

if time_values[1] != 0:

if time_values[2] != 0:

if time_values[3] != 0:

if time_values[3] % 1000 != 0:

else:

task.set("interval", text)

# Update resources pou instance attributes

def appenddataType(self, name):

if self.getdataType(name) is not None:

self.types.appenddataTypeElement(name)

setattr(cls, "appenddataType", appenddataType)

found = True

break

if not found:

setattr(cls, "removedataTypeElement", removedataTypeElement)

def getpouElements(self):

def appendpouElement(self, name, pou_type, body_type):

for element in self.pous.getpou():

if TextMatched(element.getname(), name):

new_pou = PLCOpenParser.CreateElement("pou", "pous")

self.pous.appendpou(new_pou)

new_pou.setname(name)

found = True

break

if not found:

setattr(cls, "removepouElement", removepouElement)

def Search(self, criteria, parent_infos=[]):

if body_type in ["IL", "ST", "LD", "FBD", "SFC"]:

self.body[0].setcontent(PLCOpenParser.CreateElement(body_type, "body"))

else:

setattr(cls, "setbodyType", setbodyType)

def getbodyType(self):

removed = True

break

if not removed:

setattr(cls, "removetransition", removetransition)

def addaction(self, name, body_type):

removed = True

break

if not removed:

setattr(cls, "removeaction", removeaction)

def updateElementName(self, old_name, new_name):

if body_type in ["IL", "ST", "LD", "FBD", "SFC"]:

self.body.setcontent(PLCOpenParser.CreateElement(body_type, "body"))

else:

def getbodyType(self):

return self.body.getcontent().getLocalTag()

if self.content.getLocalTag() in ["LD","FBD","SFC"]:

self.content.appendcontent(instance)

else:

setattr(cls, "appendcontentInstance", appendcontentInstance)

def getcontentInstances(self):

if self.content.getLocalTag() in ["LD","FBD","SFC"]:

return self.content.getcontent()

else:

setattr(cls, "getcontentInstances", getcontentInstances)

instance_by_id_xpath = PLCOpen_XPath("*[@localId=$localId]")

return instance[0]

return None

else:

setattr(cls, "getcontentInstance", getcontentInstance)

def getcontentInstancesIds(self):

return OrderedDict([(instance.getlocalId(), True)

for instance in self.content])

else:

setattr(cls, "getcontentInstancesIds", getcontentInstancesIds)

def getcontentInstanceByName(self, name):

return instance[0]

return None

else:

setattr(cls, "getcontentInstanceByName", getcontentInstanceByName)

def removecontentInstance(self, local_id):

if len(instance) > 0:

self.content.remove(instance[0])

else:

else:

setattr(cls, "removecontentInstance", removecontentInstance)

def settext(self, text):

if self.content.getLocalTag() in ["IL","ST"]:

self.content.setanyText(text)

else:

setattr(cls, "settext", settext)

def gettext(self):

if self.content.getLocalTag() in ["IL","ST"]:

return self.content.getanyText()

else:

setattr(cls, "gettext", gettext)

def hasblock(self, block_type):

if self.content.getLocalTag() in ["IL","ST"]:

return self.content.hasblock(block_type)

else:

setattr(cls, "hasblock", hasblock)

def updateElementName(self, old_name, new_name):

elif opened == closed:

i += 1

else:

return items

cls = PLCOpenParser.GetElementClass("arrayValue", "value")

value = element.getvalue()

if value is None:

value = ""

else:

values.append(element.getvalue())

setattr(cls, "getvalue", getvalue)

cls = PLCOpenParser.GetElementClass("structValue", "value")

def getvalue(self):

values = []

for element in self.value:

setattr(cls, "getvalue", getvalue)

param_name = param_type

param_type = variables[param_type]

elif len_of_not_predifined_variable > 1:

base += 1

else:

param_name = "IN"

# write generated content to python file

runtimefile_path = os.path.join(buildpath,

runtimefile = open(runtimefile_path, 'w')

runtimefile.write(PyFileContent.encode('utf-8'))

runtimefile.close()

}

""" % locals()

pycfile = open(Gen_PyCfile_path,'w')

pycfile.write(PyCFileContent)

pycfile.close()

self.GetCTRoot().GetIECLibPath())

return ([(Gen_PyCfile_path, matiec_CFLAGS)],

"",

True,

Calls init, start, stop or cleanup method provided by

runtime python files, loaded when new PLC uploaded

"""

res,exp = self.evaluator(method)

if exp is not None:

self.LogMessage(0,'\n'.join(traceback.format_exception(*exp)))

try :

t = self.python_runtime_vars["_"+name+"_ctype"]

except KeyError:

v = t()

r = self.python_runtime_vars["_PySafeGetPLCGlob_"+name](ctypes.byref(v))

return self.python_runtime_vars["_"+name+"_unpack"](v)

try :

t = self.python_runtime_vars["_"+name+"_ctype"]

except KeyError:

v = self.python_runtime_vars["_"+name+"_pack"](t,value)

self.python_runtime_vars["_PySafeSetPLCGlob_"+name](ctypes.byref(v))

"PLCGlobalsDesc" : []})

for methodname in MethodNames :

try:

filenames = os.listdir(self.workingdir)

for methodname in MethodNames:

method = self.python_runtime_vars.get("_%s_%s" % (name, methodname), None)

if method is not None:

except:

self.LogMessage(0,traceback.format_exc())

raise

result,exp = self.evaluator(eval,AST,self.python_runtime_vars)

if exp is not None:

res = "#EXCEPTION : "+str(exp[1])

'\n'.join(traceback.format_exception(*exp))))

else:

res=str(result)

self.python_runtime_vars["FBID"]=None

except Exception,e:

res = "#EXCEPTION : "+str(e)

def StartPLC(self):

if self.CurrentPLCFilename is not None and self.PLCStatus == "Stopped":

self.UnLoadPLC()

self.PLCStatus = "Empty"

try:

def _RegisterService(self, name, ip, port):

# name: fully qualified service name

self.name = name

self.port = port

tmpl = read_boilerplate(data_dir, "all.cache.html")

parser = pyjs.PlatformParser("platform")

app_headers = ''

for script in js_includes]

app_body = '\n'.join(scripts)

# raise TranslationError("unsupported type (in _method)", default_node)

default_name = arg_names[default_pos]

print >>self.output, " %s=__kwargs.%s;"% (default_name, default_name)

default_pos += 1

jsmodules = {"LiveSVGPage": "svguilib.js"}

res += (("svguilib.js", file(svguilibpath,"rb")),)

runtimefile = open(runtimefile_path, 'w')

runtimefile.write(svguiservercode % {"svgfile" : "gui.svg"})

runtimefile.write("""

})

runtimefile.close()

return res

if os.path.isfile(svgpath):

shutil.copy(svgpath, self._getSVGpath())

else:

dialog.Destroy()

def _StartInkscape(self):

xeno_config + " --skin=native --"+flagsname,

no_stdout=True).spin()

if status:

return [result.strip()]

return []

"class":_GetLocalTargetClassFactory(name),

"code": { fname: path.join(_base_path, name, fname)

for fname in listdir(path.join(_base_path, name))

fname.endswith(".c")}})

for name in listdir(_base_path)

if path.isdir(path.join(_base_path, name))

# Get all xsd targets

for targetname,nfo in targets.iteritems():

xsd_string = open(nfo["xsd"]).read()

return targetchoices

if status :

self.srcmd5.pop(bn)

return False

obns.append(obn)

objs.append(objectfilename)

path = self.GetWxGladePath()

glade = os.path.join(path, 'wxglade.py')

if wx.Platform == '__WXMSW__':

mode = {False:os.P_NOWAIT, True:os.P_WAIT}[wait]

def OnCTNSave(self, from_project_path=None):

if from_project_path is not None:

hmipyfile_path=os.path.join(self._getBuildPath(), "hmi.py")

if wx.Platform == '__WXMSW__':

else:

wxghmipyfile_path = hmipyfile_path

self.launch_wxglade(['-o', wxghmipyfile_path, '-g', 'python', wxgfile_path], wait=True)

"\n".join(["%(class)s.%(h)s = %(h)s"%

dict(x,h=h) for h in x['handlers']])

for x in hmi_frames])

[x["name"] for x in hmi_frames])

if len(hmi_frames) > 0 else "")

init_hmi = "\n".join(["""\

</application>

""" % {"name": hmi_name, "class": "Class_%s" % hmi_name})

if wx.Platform == '__WXMSW__':

self.launch_wxglade([wxg_filename])

for child in node.childNodes:

if child.nodeName not in ["#comment", "#text"]:

namespace, childname = DecomposeQualifiedName(child.nodeName)

result = elements_model.match(children_structure)

if not result:

raise ValueError("Invalid structure for \"%s\" children!. First element invalid." % node.nodeName)

raise ValueError("\"%s\" type is not a simple type!" % attribute["attr_type"])

attrname = attribute["name"]

if attribute["use"] == "optional":

else:

raise ValueError("\"%s\" type unrecognized!" % attribute["attr_type"])

attribute["attr_type"] = infos

if element["type"] == CHOICE:

elmtname = element["name"]

choices = ComputeContentChoices(self, name, element)

if element["maxOccurs"] == "unbounded" or element["maxOccurs"] > 1:

classmembers["append%sbytype" % elmtname] = generateAppendChoiceByTypeMethod(element["maxOccurs"], self, element["choices"])

classmembers["insert%sbytype" % elmtname] = generateInsertChoiceByTypeMethod(element["maxOccurs"], self, element["choices"])

annotation["appinfo"].append((child["source"], child["content"]))

elif child["type"] == "documentation":

if child["source"] is not None:

else:

text = child["content"] + "\n\n"

if not annotation["documentation"].has_key(child["language"]):

elements_tmp = []

for element in elmtgroup["elements"]:

if not isinstance(element["elmt_type"], (UnicodeType, StringType)) and element["elmt_type"]["type"] == COMPLEXTYPE:

if factory.TargetNamespace is not None:

elmt_type = "%s:%s" % (factory.TargetNamespace, elmt_type)

new_element = element.copy()

"basename": "hexBinary",

"extract": GetHexInteger,

"facets": STRING_FACETS,

"initial": lambda: 0,

"check": lambda x: isinstance(x, (IntType, LongType))

},