base_folder = paths.AbsParentDir(__file__)

def ExtractChildrenTypesFromCatalog(catalog):

class Iec2CSettings(object):

def __init__(self):

self.iec2c = None

self.iec2c_buildopts = None

return path

def findCmd(self):

paths = [

os.path.join(base_folder, "matiec")

]

# otherwise use iec2c from PATH

if path is not None:

os.path.join(base_folder, "matiec", "lib"),

"/usr/lib/matiec"

]

return path

def findLibCPath(self):

buildopt = ""

try:

_status, result, _err_result = ProcessLogger(None, buildcmd,

no_stdout=True,

no_stderr=True).spin()

<xsd:element name="TargetType">

<xsd:complexType>

<xsd:choice minOccurs="0">

</xsd:choice>

</xsd:complexType>

<xsd:element name="Libraries" minOccurs="0">

<xsd:complexType>

</xsd:complexType>

</xsd:element>""") if len(features.libraries) > 0 else '') + """

</xsd:sequence>

</xsd:element>

</xsd:schema>

"""

return XSD

class ProjectController(ConfigTreeNode, PLCControler):

"""

This class define Root object of the confnode tree.

It is responsible of :

- ...

"""

CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

XSD = GetProjectControllerXSD()

EditorType = ProjectNodeEditor

def LoadLibraries(self):

self.Libraries = []

TypeStack = []

Lib = GetClassImporter(clsname)()(self, libname, TypeStack)

TypeStack.append(Lib.GetTypes())

self.Libraries.append(Lib)

target = self.Parser.CreateElement("TargetType", "BeremizRoot")

temp_root.setTargetType(target)

target_name = self.GetDefaultTargetName()

return target

def GetParamsAttributes(self, path=None):

if params[0]["name"] == "BeremizRoot":

for child in params[0]["children"]:

if child["name"] == "TargetType" and child["value"] == '':

return params

def SetParamsAttribute(self, path, value):

def _getProjectFilesPath(self, project_path=None):

if project_path is not None:

return os.path.join(project_path, "project_files")

if not os.path.exists(projectfiles_path):

os.mkdir(projectfiles_path)

return projectfiles_path

def SetProjectDefaultConfiguration(self):

# Sets default task and instance for new project

resource = config.getresource()[0].getname()

config = config.getname()

resource_tagname = ComputeConfigurationResourceName(config, resource)

if error is not None:

if self.Project is not None:

(fname_err, lnum, src) = (("PLC",) + error)

else:

return error, False

if len(self.GetProjectConfigNames()) == 0:

def CheckNewProjectPath(self, old_project_path, new_project_path):

if old_project_path == new_project_path:

message = (_("Save path is the same as path of a project! \n"))

dialog.ShowModal()

return False

else:

plc_file = os.path.join(new_project_path, "plc.xml")

if os.path.isfile(plc_file):

answer = dialog.ShowModal()

return answer == wx.ID_YES

return True

def SaveProject(self, from_project_path=None):

if self.CheckProjectPathPerm(False):

if from_project_path is not None:

if os.path.isdir(old_projectfiles_path):

shutil.copytree(old_projectfiles_path,

self._getProjectFilesPath(self.ProjectPath))

path = os.getenv("USERPROFILE")

else:

path = os.getenv("HOME")

answer = dirdialog.ShowModal()

dirdialog.Destroy()

if answer == wx.ID_OK:

if len(self.Libraries) == 0:

return [], [], ()

self.GetIECProgramsAndVariables()

LocatedCCodeAndFlags = []

Extras = []

for lib in self.Libraries:

LocatedCCodeAndFlags.append(res[:2])

if len(res) > 2:

Extras.extend(res[2:])

# Update PLCOpenEditor ConfNode Block types from loaded confnodes

def RefreshConfNodesBlockLists(self):

self.DefaultBuildPath = os.path.join(self.ProjectPath, "build")

# Create a build path in temp folder

else:

if not os.path.exists(self.DefaultBuildPath):

os.makedirs(self.DefaultBuildPath)

locations = []

filepath = os.path.join(self._getBuildPath(), "LOCATED_VARIABLES.h")

if os.path.isfile(filepath):

# each line of LOCATED_VARIABLES.h declares a located variable

lines = [line.strip() for line in location_file.readlines()]

# This regular expression parses the lines genereated by IEC2C

for line in lines:

# If line match RE,

result = LOCATED_MODEL.match(line)

if result:

# Get the resulting dict

resdict = result.groupdict()

resdict['LOC'] = tuple(map(int, resdict['LOC'].split(',')))

# set located size to 'X' if not given

if not resdict['SIZE']:

# Update PLCOpenEditor ConfNode Block types before generate ST code

self.RefreshConfNodesBlockLists()

# ask PLCOpenEditor controller to write ST/IL/SFC code file

if len(warnings) > 0:

for warning in warnings:

self.logger.write_warning("%s\n" % warning)

if len(errors) > 0:

# Failed !

return False

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

# Add ST Library from confnodes

self._getIECcodepath())

try:

status, result, err_result = ProcessLogger(self.logger, buildcmd,

except Exception, e:

self.logger.write_error(buildcmd + "\n")

self.logger.write_error(repr(e) + "\n")

if first_line <= i <= last_line:

if last_section is not None:

last_section = None # only write section once

self.logger.write_warning("%04d: %s" % (i, line))

f.close()

return False

# Now extract C files of stdout

# remove those that are not to be compiled because included by others

C_files.remove("POUS.c")

if not C_files:

return False

# transform those base names to full names with path

# prepend beremiz include to configuration header

H_files.remove("LOCATED_VARIABLES.h")

for H_file in H_files:

with file(H_file, 'r') as original:

data = original.read()

modified.write('#include "beremiz.h"\n' + data)

self.logger.write(_("Extracting Located Variables...\n"))

self.PLCGeneratedLocatedVars = self.GetLocations()

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

self.PLCGeneratedCFiles = C_files

else:

return None

#

# C CODE GENERATION METHODS

#

def CTNGenerate_C(self, buildpath, locations):

"""

csvfile = os.path.join(self._getBuildPath(), "VARIABLES.csv")

# describes CSV columns

ProgramsListAttributeName = ["num", "C_path", "type"]

self._ProgramList = []

self._VariablesList = []

self._DbgVariablesList = []

# first section contains programs

for line in ListGroup[0]:

# Split and Maps each field to dictionnary entries

# Truncate "C_path" to remove conf an resources names

# Push this dictionnary into result.

self._ProgramList.append(attrs)

Idx = 0

for line in ListGroup[1]:

# Split and Maps each field to dictionnary entries

# Truncate "C_path" to remove conf an resources names

parts = attrs["C_path"].split(".", 2)

if len(parts) > 2:

self._Ticktime = int(ListGroup[2][0])

except Exception:

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

self.ResetIECProgramsAndVariables()

return False

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

"__retrieve_%s();" % locstr for locstr in locstrs]),

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

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

"if((res = __init_%s(argc,argv))){" % locstr +

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

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

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

"if(init_level >= %d) " % i +

else:

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

"calls_prototypes": "\n",

"init_calls": "\n",

"cleanup_calls": "\n"

}

plc_main_code += targets.GetCode("plc_main_tail.c")

return plc_main_code

buildpath,

self.PLCGeneratedLocatedVars)

except Exception:

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

self.ResetBuildMD5()

return False

# Generate C code and compilation params from liraries

try:

except Exception:

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

self.ResetBuildMD5()

return False

self.LDFLAGS = CTNLDFLAGS + LibLDFLAGS

ExtraFiles = CTNExtraFiles + LibExtraFiles

del ExtraFiles

# Header file for extensions

# Template based part of C code generation

# files are stacked at the beginning, as files of confnode tree root

raise Exception

code_path = os.path.join(buildpath, filename)

open(code_path, "w").write(code)

except Exception:

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

self.ResetBuildMD5()

return False

def ShowError(self, logger, from_location, to_location):

chunk_infos = self.GetChunkInfos(from_location, to_location)

for infos, (start_row, start_col) in chunk_infos:

start = (row, col)

end = (row, col)

if self.AppFrame is not None:

if self._IECCodeView is None:

plc_file = self._getIECcodepath()

self._IECCodeView.SetTextSyntax("ALL")

self._IECCodeView.SetKeywords(IEC_KEYWORDS)

try:

if self._IECRawCodeView is None:

controler = MiniTextControler(self._getIECrawcodepath(), self)

self._IECRawCodeView.SetTextSyntax("ALL")

self._IECRawCodeView.SetKeywords(IEC_KEYWORDS)

self._IECRawCodeView.RefreshView()

elif name == "Project Files":

if self._ProjectFilesView is None:

extensions = []

for extension, name, editor in features.file_editors:

name = "::".join([filepath, editor_name])

editor = editors[editor_name]()

self._FileEditors[filepath].SetIcon(GetBitmap("FILE"))

if isinstance(self._FileEditors[filepath], DebugViewer):

self._FileEditors[filepath].SetDataProducer(self)

allmethods.update(

self.MethodsFromStatus.get(status, {}))

for method, active in allmethods.items():

self.previous_plcstate = status

if self.AppFrame is not None:

updated = True

self.AppFrame.RefreshStatusToolBar()

if status == "Disconnected":

self.AppFrame.ConnectionStatusBar.SetStatusText('', 2)

else:

self.AppFrame.ConnectionStatusBar.SetStatusText(

_("Connected to URI: %s") % self.BeremizRoot.getURI_location().strip(), 1)

return updated

def GetTextStatus(self, status):

"Empty": _("Empty"),

"Broken": _("Broken"),

"Disconnected": _("Disconnected")

return msgs.get(status, status)

def ShowPLCProgress(self, status="", progress=0):

self.AppFrame.ProgressStatusBar.Show()

self.AppFrame.ProgressStatusBar.SetValue(progress)

def HidePLCProgress(self):

def SnapshotAndResetDebugValuesBuffers(self):

if self._connector is not None:

plc_status, Traces = self._connector.GetTraceVariables()

if plc_status == "Started":

if len(Traces) > 0:

for debug_tick, debug_buff in Traces:

if debug_vars is not None and len(debug_vars) == len(self.TracedIECPath):

for IECPath, values_buffer, value in izip(

self.TracedIECPath,

self.DebugValuesBuffers,

debug_vars):

if IECdebug_data is not None and value is not None:

if not IECdebug_data[4] and len(values_buffer) > 0:

values_buffer[-1] = (value, forced)

else:

IECPathsToPop.append(IECPath)

elif IECPath != "__tick__":

# Convert

if Idx is not None:

if IEC_Type in DebugTypesSize:

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

else:

else:

for IECPathToPop in IECPathsToPop:

self.IECdebug_datas.pop(IECPathToPop)

# Links between PLC located variables and real variables are not ready

if self.IsPLCStarted():

# Timer to prevent rapid-fire when registering many variables

# Rearm anti-rapid-fire timer

self.DebugTimer.start()

if len(self.TracedIECPath) == len(buffers):

for IECPath, values in izip(self.TracedIECPath, buffers):

if len(values) > 0:

if len(debug_ticks) > 0:

delay = time.time() - start_time

next_refresh = max(REFRESH_PERIOD - delay, 0.2 * delay)

def _Connect(self):

# don't accept re-connetion if already connected

if self._connector is not None:

return

# Get connector uri

try:

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

except Exception:

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

# Did connection success ?

self.logger.write(_("Debugger ready\n"))

self._connect_debug()

else:

def CompareLocalAndRemotePLC(self):

if self._connector is None:

if MD5 is not None:

if not self._connector.MatchMD5(MD5):

# self.logger.write_warning(

self.EnableMethod("_Transfer", True)

else:

# self.logger.write(

# Check if md5 file is empty : ask user to build PLC

if MD5 is None:

return False

# Compare PLC project with PLC on target

self.logger.write_error(_("Transfer failed\n"))

self.HidePLCProgress()

else:

wx.CallAfter(self.UpdateMethodsFromPLCStatus)

# de-activated dumb wamp config

defaultWampConfig = {

"url": "ws://127.0.0.1:8888"

}

lastKnownConfig = None

def GetCallee(name):

""" Get Callee or Subscriber corresponding to '.' spearated object path """

names = name.split('.')

class WampSession(wamp.ApplicationSession):

def onConnect(self):

if "secret" in self.config.extra:

user = self.config.extra["ID"]

if challenge.method == u"wampcra":

if "secret" in self.config.extra:

secret = self.config.extra["secret"].encode('utf8')

return signature.decode("ascii")

else:

raise Exception("no secret given for authentication")

else:

@inlineCallbacks

def onJoin(self, details):

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

def __init__(self, config, *args, **kwargs):

global _transportFactory

WampWebSocketClientFactory.__init__(self, *args, **kwargs)

def clientConnectionFailed(self, connector, reason):

if self.continueTrying:

else:

del connector

def clientConnectionLost(self, connector, reason):

if self.continueTrying:

else:

del connector

url = WampClientConf["url"]

if not IsCorrectUri(url):

raise annotate.ValidateError(

_("WAMP configuration error:"))

def GetConfiguration():

global lastKnownConfig

if os.path.exists(_WampConf):

WampClientConf = json.load(open(_WampConf))

WampClientConf = defaultWampConfig.copy()

for itemName in mandatoryConfigItems:

CheckConfiguration(WampClientConf)

with open(os.path.realpath(_WampSecret), 'w') as f:

f.write(wampSecret)

def SetConfiguration(WampClientConf):

global lastKnownConfig

CheckConfiguration(WampClientConf)

lastKnownConfig = WampClientConf.copy()

with open(os.path.realpath(_WampConf), 'w') as f:

json.dump(WampClientConf, f, sort_keys=True, indent=4)

if 'active' in WampClientConf and WampClientConf['active']:

def LoadWampSecret(secretfname):

WSClientWampSecret = open(secretfname, 'rb').read()

raise Exception(_("WAMP secret empty"))

return WSClientWampSecret

# set secret file path only if not already set

if _WampSecret is None:

if os.path.exists(_WampSecretDefault):

_WampSecret = _WampSecretDefault

else:

if _WampSecret is not None:

WampClientConf["secret"] = LoadWampSecret(_WampSecret)

print(_("WAMP authentication has no secret configured"))

_WampSecret = _WampSecretDefault

# start the client from a Twisted endpoint

if _transportFactory:

print(_("WAMP client connecting to :"), WampClientConf["url"])

return True

else:

def StopReconnectWampClient():

_transportFactory.stopTrying()

_WampSession.leave()

def GetSession():

return _WampSession

def getWampStatus():

return "Attached"

return "Established"

return "Connecting"

_PySrv = pysrv

WAMP_SECRET_URL = "secret"

webExposedConfigItems = ['active', 'url', 'ID']

return lastKnownConfig.get(argument.name, None)

def wampConfig(**kwargs):

secretfile_field = kwargs["secretfile"]

if secretfile_field is not None:

newConfig = lastKnownConfig.copy()

for argname in webExposedConfigItems:

arg = kwargs.get(argname, None)

newConfig[argname] = arg

SetConfiguration(newConfig)

class FileUploadDownload(annotate.FileUpload):

pass

class FileUploadDownloadRenderer(webform.FileUploadRenderer):

def input(self, context, slot, data, name, value):

slot[_("Upload:")]

download_url = data.typedValue.getAttribute('download_url')

return slot[tags.a(href=download_url)[_("Download")]]

def getDownloadUrl(ctx, argument):

return url.URL.fromContext(ctx).\

child(WAMP_SECRET_URL).\

webFormInterface = [

("status",

("ID",

("secretfile",

("active",

("url",

def deliverWampSecret(ctx, segments):

# FIXME: compare filename to ID+".secret"

# for now all url under /secret returns the secret

# while loading secret (if empty or dont exist)

secret = LoadWampSecret(_WampSecret)

def RegisterWebSettings(NS):

NS.ConfigurableSettings.addExtension(

_("Wamp Settings"),

webFormInterface,

_("Set"),

wampConfig)

NS.customSettingsURLs[WAMP_SECRET_URL] = deliverWampSecret

if wx.Platform == '__WXMSW__':

glade = "\"%s\"" % glade

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

def OnCTNSave(self, from_project_path=None):

if from_project_path is not None:

# list containing description of all objects declared in wxglade

hmi_objects = []

main_frames = []

wxgfile_path = self._getWXGLADEpath()

node.getElementsByTagName("handler")]}

hmi_objects.append(wxglade_object_desc)

main_frames.append(wxglade_object_desc)

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

wxghmipyfile_path = "\"%s\"" % hmipyfile_path

else:

wxghmipyfile_path = hmipyfile_path

hmipyfile = open(hmipyfile_path, 'r')

define_hmi = hmipyfile.read().decode('utf-8')

declare_hmi = "\n".join(["%(name)s = None\n" % x for x in main_frames])

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

global_hmi = ("global %s\n" % ",".join(

[x["name"] for x in main_frames]) if len(main_frames) > 0 else "")

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

if len(main_frames) == 0 and \

len(getattr(self.CodeFile, "start").getanyText().strip()) == 0:

return PythonFileCTNMixin.CTNGenerate_C(self, buildpath, locations)

def _editWXGLADE(self):