# Twisted reactor needs to be stopped only before quit,

# since it cannot be restarted

ToDoBeforeQuit = []

def AddToDoBeforeQuit(self, Thing):

self.ToDoBeforeQuit.append(Thing)

class _VariableInfos(object):

__slots__ = ["Name", "Class", "Option", "Location", "InitialValue",

"Edit", "Documentation", "Type", "Tree", "Number"]

def __init__(self, *args):

for attr, value in zip(self.__slots__, args):

setattr(self, attr, value if value is not None else "")

def copy(self):

return _VariableInfos(*[getattr(self, attr) for attr in self.__slots__])

class _VariablesTreeItemInfos(object):

__slots__ = ["name", "var_class", "type", "edit", "debug", "variables"]

def __init__(self, *args):

for attr, value in zip(self.__slots__, args):

setattr(self, attr, value if value is not None else "")

def copy(self):

return _VariableTreeItem(*[getattr(self, attr) for attr in self.__slots__])

class _ActionInfos(object):

__slots__ = ["qualifier", "type", "value", "duration", "indicator"]

def __init__(self, *args):

for attr, value in zip(self.__slots__, args):

setattr(self, attr, value if value is not None else "")

def copy(self):

return _ActionInfos(*[getattr(self, attr) for attr in self.__slots__])

self.Interface.append((varTypeNames[varlist_type], option, True, located))

LITERAL_TYPES = {

"TOD": "TIME_OF_DAY",

}

def ComputeConnectionTypes(self, pou):

body = pou.getbody()

if isinstance(body, ListType):

self.AppFrame.ShowError(infos, start, end)

_IECCodeView = None

def _showIECcode(self):

self._OpenView("IEC code")

_IECRawCodeView = None

def _editIECrawcode(self):

self._OpenView("IEC raw code")

_ProjectFilesView = None

def _OpenProjectFiles(self):

self._OpenView("Project Files")

_FileEditors = {}

def _OpenFileEditor(self, filepath):

self._OpenView(filepath)

}

_GeneratedMasterView = None

def _ShowGeneratedMaster(self):

self._OpenView("Generated master")

CTNChildrenTypes = [("CanOpenNode", _NodeListCTN, "CanOpen Master"),

("CanOpenSlave", _SlaveCTN, "CanOpen Slave")]

def GetParamsAttributes(self, path=None):

infos = ConfigTreeNode.GetParamsAttributes(self, path=path)

for element in infos:

datatypes_xpath = PLCOpen_XPath("ppx:types/ppx:dataTypes/ppx:dataType")

filtered_datatypes_xpath = PLCOpen_XPath(

"ppx:types/ppx:dataTypes/ppx:dataType[@name!=$exclude]")

def getdataTypes(self, exclude=None):

if exclude is not None:

return filtered_datatypes_xpath(self, exclude=exclude)

configurations_xpath = PLCOpen_XPath(

"ppx:instances/ppx:configurations/ppx:configuration")

def getconfigurations(self):

return configurations_xpath(self)

setattr(cls, "getconfigurations", getconfigurations)

configuration_xpath = PLCOpen_XPath(

"ppx:instances/ppx:configurations/ppx:configuration[@name=$name]")

def getconfiguration(self, name):

configurations = configuration_xpath(self, name=name)

if len(configurations) == 1:

resources_xpath = PLCOpen_XPath(

"ppx:instances/ppx:configurations/ppx:configuration[@name=$configname]/ppx:resource[@name=$name]")

def getconfigurationResource(self, config_name, name):

resources = resources_xpath(self, configname=config_name, name=name)

if len(resources) == 1:

enumerated_values_xpath = PLCOpen_XPath(

"ppx:types/ppx:dataTypes/ppx:dataType/ppx:baseType/ppx:enum/ppx:values/ppx:value")

def GetEnumeratedDataTypeValues(self):

return [value.getname() for value in enumerated_values_xpath(self)]

setattr(cls, "GetEnumeratedDataTypeValues", GetEnumeratedDataTypeValues)

setattr(cls, "updateElementName", updateElementName)

enumerated_datatype_values_xpath = PLCOpen_XPath("ppx:values/ppx:value")

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

search_result = []

for i, value in enumerate(enumerated_datatype_values_xpath(self)):

"ppx:interface/*[self::ppx:inputVars or self::ppx:inOutVars]/ppx:variable")

block_outputs_xpath = PLCOpen_XPath(

"ppx:interface/*[self::ppx:outputVars or self::ppx:inOutVars]/ppx:variable")

def getblockInfos(self):

block_infos = {

"name": self.getname(),

if cls:

cls.currentExecutionOrderId = 0

cls.checkedBlocksDict = {}

def resetcurrentExecutionOrderId(self):

object.__setattr__(self, "currentExecutionOrderId", 0)

setattr(cls, "resetcurrentExecutionOrderId", resetcurrentExecutionOrderId)

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

instance_by_name_xpath = PLCOpen_XPath("ppx:block[@instanceName=$name]")

def getcontentInstance(self, local_id):

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

instance = instance_by_id_xpath(self.content, localId=local_id)

connection_xpath = PLCOpen_XPath("ppx:connection")

connection_by_position_xpath = PLCOpen_XPath("ppx:connection[position()=$pos]")

def getconnections(self):

return connection_xpath(self)

setattr(cls, "getconnections", getconnections)

PreSectionsTexts = {}

PostSectionsTexts = {}

def GetSection(self, section):

return self.PreSectionsTexts.get(section, "") + "\n" + \

getattr(self.CodeFile, section).getanyText() + "\n" + \

def clientConnectionFailed(self, connector, reason):

print("WAMP Client connection failed .. retrying ..")

self.retry(connector)

def clientConnectionLost(self, connector, reason):

print("WAMP Client connection lost .. retrying ..")

self.retry(connector)

def response(self, id, result):

return simplejson.dumps({'version': '1.1', 'id': id,

'result': result, 'error': None})

def error(self, id, code, message):

return simplejson.dumps({'id': id,

'version': '1.1',

class Linux_target(toolchain_gcc):

dlopen_prefix = "./"

extension = ".so"

def getBuilderCFLAGS(self):

return toolchain_gcc.getBuilderCFLAGS(self) + ["-fPIC"]

def getBuilderLDFLAGS(self):

return toolchain_gcc.getBuilderLDFLAGS(self) + ["-shared", "-lrt"]

class Win32_target(toolchain_gcc):

dlopen_prefix = ""

extension = ".dll"

def getBuilderLDFLAGS(self):

return toolchain_gcc.getBuilderLDFLAGS(self) + ["-shared", "-lwinmm"]

class Xenomai_target(toolchain_gcc):

dlopen_prefix = "./"

extension = ".so"

def getXenoConfig(self, flagsname):

""" Get xeno-config from target parameters """

xeno_config = self.CTRInstance.GetTarget().getcontent().getXenoConfig()