}

else:

faces = {

'size': 10,

}

variable.gettype(),

variable.getinitial())

for variable in variables]

return ret

def CTNSearch(self, criteria):

from xmlclass import GenerateParserFromXSDstring

from PLCControler import LOCATION_CONFNODE

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

_BaseParamsParser = GenerateParserFromXSDstring("""<?xml version="1.0" encoding="ISO-8859-1" ?>

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

def GetContextualMenuItems(self):

return None

app_frame = self.GetCTRoot().AppFrame

self._View = self.EditorType(app_frame.TabsOpened, self, app_frame)

return self._View

def _OpenView(self, name=None, onlyopened=False):

if view is not None:

if name is None:

name = self.CTNFullName()

app_frame = self.GetCTRoot().AppFrame

return view

no_stdout=True,

no_stderr=True).spin()

except Exception:

return buildopt

for opt in options:

# Setup debug information

self.IECdebug_datas = {}

self.ResetIECProgramsAndVariables()

# In both new or load scenario, no need to save

self.debug_status = PlcStatus.Stopped

def __del__(self):

self.KillDebugThread()

def LoadLibraries(self):

return debug_status, ticks, buffers

def RegisterDebugVarToConnector(self):

Idxs = []

self.TracedIECPath = []

self.TracedIECTypes = []

self._connector.SetTraceVariablesList([])

self.DebugToken = None

self.debug_status, _debug_ticks, _buffers = self.SnapshotAndResetDebugValuesBuffers()

def IsPLCStarted(self):

return self.previous_plcstate == PlcStatus.Started

def GetDebugIECVariableType(self, IECPath):

_Idx, IEC_Type = self._IECPathToIdx.get(IECPath, (None, None))

IECdebug_data[0][callableobj] = buffer_list

return IECdebug_data[1]

IECdebug_data[0].itervalues(),

False)

def UnsubscribeAllDebugIECVariable(self):

self.IECdebug_datas = {}

def ForceDebugIECVariable(self, IECPath, fvalue):

if IECPath not in self.IECdebug_datas:

IECdebug_data[2] = "Forced"

IECdebug_data[3] = fvalue

def ReleaseDebugIECVariable(self, IECPath):

if IECPath not in self.IECdebug_datas:

IECdebug_data[2] = "Registered"

IECdebug_data[3] = None

def CallWeakcallables(self, IECPath, function_name, *cargs):

data_tuple = self.IECdebug_datas.get(IECPath, None)

# print(self.xslt.error_log)

return res

runtimefile.close()

return ([(Generated_BACnet_c_mainfile_name, CFLAGS)], LDFLAGS, True,

)

#return [(Generated_BACnet_c_mainfile_name, CFLAGS)], LDFLAGS, True, ('extrafile1.txt', extra_file_handle)

# location_str is replaced by extension's value in CTNGenerateC call

"""

# Callback function, called (by PLCObject.py) when a new PLC program

# (i.e. XXX.so file) is transfered to the PLC runtime

# location_str is replaced by extension's value in CTNGenerateC call

"""

# Callback function, called (by PLCObject.py) when a PLC program is unloaded from memory

"""

else:

faces = {

'times': 'Times',

'helv': 'Helvetica',

'other': 'new century schoolbook',

'size': 12,

if wx.Platform == '__WXMSW__':

self.Font = wx.Font(8, wx.SWISS, wx.NORMAL, wx.NORMAL, faceName='Courier New')

else:

self.MessagePanel.Bind(wx.EVT_LEFT_UP, self.OnMessagePanelLeftUp)

self.MessagePanel.Bind(wx.EVT_RIGHT_UP, self.OnMessagePanelRightUp)

self.MessagePanel.Bind(wx.EVT_LEFT_DCLICK, self.OnMessagePanelLeftDCLick)

if wx.Platform == '__WXMSW__':

from six.moves import winreg

try:

except OSError:

svgexepath = svgexepath.replace('"%1"', '').strip()

return svgexepath.replace('"', '')

else:

def open_win_svg(svgexepath, svgfile):

else:

faces = {

'times': 'Times',

'helv': 'Helvetica',

'other': 'new century schoolbook',

'size': 18,

else:

faces = {

'times': 'Times',

'helv': 'Helvetica',

'other': 'new century schoolbook',

'size': 10,

return ((["etherlab_ext"], [(Gen_etherlabfile_path, IECCFLAGS)], True), "",

("runtime_etherlab.py", open(GetLocalPath("runtime_etherlab.py"))))

# --------------------------------------------------

# Ethercat MASTER

# --------------------------------------------------

time.sleep(0.5)

def _runtime_etherlab_init():

global KMSGPollThread, StopKMSGThread

StopKMSGThread = False

KMSGPollThread.start()

def _runtime_etherlab_cleanup():

global KMSGPollThread, StopKMSGThread, SDOThread

try:

runtimefile.close()

return ([(Gen_MB_c_path, ' -I"' + ModbusPath + '"')], LDFLAGS, True,

)

("baud" , _("Baud Rate") , ctypes.c_int, MB_Baud ),

("parity" , _("Parity") , ctypes.c_int, MB_Parity ),

("stop_bits" , _("Stop Bits") , ctypes.c_int, MB_StopBits ),

]

# This allows us to confirm the saved data contains the correct addr_type

# when loading from file

save_info = {}

save_info["node_type"] = WebNode_entry["node_type"]

save_info["config" ] = newConfig

filename = _WebNodeList[WebNode_id]["filename"]

try:

#if os.path.isfile(filename):

except Exception:

return None

"""

Callback function, called (by PLCObject.py) when a new PLC program

(i.e. XXX.so file) is transfered to the PLC runtime

"""

Callback function, called (by PLCObject.py) when a PLC program is unloaded from memory

"""

def SaveProject(project, filepath):

project,

pretty_print=True,

xml_declaration=True,

project_file.close()

from py_ext.PythonEditor import PythonEditor

class PythonFileCTNMixin(CodeFile):

CODEFILE_NAME = "PyFile"

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

self.PostSectionsTexts.get(section, "")

def CTNGenerate_C(self, buildpath, locations):

# location string for that CTN

location_str = "_".join(map(str, self.GetCurrentLocation()))

configname = self.GetCTRoot().GetProjectConfigNames()[0]

def _onchangecode(var):

def _onchange(var):

pyextname = self.CTNName()

varinfos = map(

"pyextname": pyextname

},

self.CodeFile.variables.variable)

# python side PLC global variables access stub

globalstubs = "\n".join([

"""\

%(desc)s,

%(onchange)s,

%(opts)s))

# Runtime calls (start, stop, init, and cleanup)

rtcalls = ""

for section in self.SECTIONS_NAMES:

"globalstubs": globalstubs,

"globalsection": globalsection,

"rtcalls": rtcalls,

}

PyFileContent = """\

## Code for PLC global variable access

from runtime.typemapping import TypeTranslator

import ctypes

_%(pyextname)sGlobalsDesc = []

__ext_name__ = "%(pyextname)s"

PLCGlobalsDesc.append(( "%(pyextname)s" , _%(pyextname)sGlobalsDesc ))

## Beremiz python runtime calls

%(rtcalls)s

del __ext_name__

""" % loc_dict

"""

vardeconchangefmt = """\

"""

varretfmt = """\

if(!AtomicCompareExchange(&__%(name)s_rlock, 0, 1)){

IEC_%(IECtype)s tmp = __GET_VAR(%(configname)s__%(uppername)s);

if(NE_%(IECtype)s(1, NULL, __%(name)s_rbuffer, tmp)){

__%(name)s_rbuffer = tmp;

}

AtomicCompareExchange((long*)&__%(name)s_rlock, 1, 0);

}

"""

"""

vardec = "\n".join([(vardecfmt + vardeconchangefmt

if varinfo["onchange"] else vardecfmt) % varinfo

varpub = "\n".join([(varpubonchangefmt if varinfo["onchange"] else

varpubfmt) % varinfo

for varinfo in varinfos])

for varinfo in varinfos if varinfo["onchange"]])

loc_dict = {

"vardec": vardec,

"varret": varret,

"varpub": varpub,

"location_str": location_str,

}

# TODO : use config name obtained from model instead of default

#include "config.h"

#include "beremiz.h"

/* User variables reference */

%(vardec)s

/* Beremiz confnode functions */

int __init_%(location_str)s(int argc,char **argv){

return 0;

}

%(varret)s

}

void __publish_%(location_str)s(void){

%(varpub)s

}

""" % loc_dict

Gen_PyCfile_path = os.path.join(buildpath, "PyCFile_%s.c" % location_str)

import util.paths as paths

from runtime.loglevels import LogLevels, LogLevelsDict

PAGE_TITLE = 'Beremiz Runtime Web Interface'

"Send a message to the log"),

action=_("Send"))

customSettingsURLs = {

}

def sendLogMessage(self, level, message, **kwargs):

level = LogLevelsDict[level]

def locateChild(self, ctx, segments):

if segments[0] in customSettingsURLs:

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

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

self.python_runtime_vars.update({

"PLCGlobals": PLCSafeGlobals(),

"WorkingDir": self.workingdir,

"PLCObject": self,

"PLCBinary": self.PLClibraryHandle,

if cmd == "Activate":

self.PythonRuntimeCall("start")

self.PythonThreadLoop()

self.PythonRuntimeCall("stop", reverse_order=True)

else: # "Finish"

if not self.LoadPLC():

self._fail(_("Problem starting PLC : can't load PLC"))

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

c_argv = ctypes.c_char_p * len(self.argv)

res = self._startPLC(len(self.argv), c_argv(*self.argv))

os.close(fd)

self._init_blobs()

blob = self.blobs.pop(blobID, None)

if blob is None:

raise Exception(_("Missing data to create file: {}").format(newpath))

fd, path, _md5sum = blob

fobj = os.fdopen(fd)

fobj.flush()

try:

# Create new PLC file

# Then write the files

log = open(extra_files_log, "w")

for fname, blobID in extrafiles:

fpath = os.path.join(self.workingdir, fname)

log.write(fname+'\n')

# Store new PLC filename based on md5 key

void __init_debug(void)

{

/* init local static vars */

buffer_cursor = debug_buffer;

buffer_state = BUFFER_FREE;

#endif

InitRetain();

/* Iterate over all variables to fill debug buffer */

if(CheckRetainBuffer()){

}else{

LogMessage(LOG_WARNING, mstr, sizeof(mstr));

}

retain_offset = 0;

void __cleanup_debug(void)

{

buffer_cursor = debug_buffer;

InitiateDebugTransfer();

#endif

if(flags & ( __IEC_DEBUG_FLAG | __IEC_RETAIN_FLAG)){

USINT size = __get_type_enum_size(dsc->type);

if(flags & __IEC_DEBUG_FLAG){

/* copy visible variable to buffer */;

if(do_debug){

/* compute next cursor positon.

No need to check overflow, as BUFFER_SIZE

is computed large enough */

/* optimization for strings */

size = ((STRING*)visible_value_p)->len + 1;

}

memcpy(real_value_p, visible_value_p, size);

}

}

if(flags & __IEC_RETAIN_FLAG){

/* compute next cursor positon*/

forced_value_p = &((__IEC_##TYPENAME##_p *)varp)->fvalue;\

break;

static void* UnpackVar(__Unpack_desc_type *dsc, void **real_value_p, char *flags)

{

void *varp = dsc->ptr;

<?xml version='1.0' encoding='utf-8'?>

<project xmlns="http://www.plcopen.org/xml/tc6_0201" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xhtml="http://www.w3.org/1999/xhtml" xsi:schemaLocation="http://www.plcopen.org/xml/tc6_0201">

<fileHeader companyName="" productName="Beremiz" productVersion="0.0" creationDateTime="2008-12-14T16:21:19" contentDescription="This example shows many features in Beremiz:&#10;&#10; 1. How to implement python extensions.&#10; 2. How to implement basic C extension.&#10; 3. How to use C code in IEC POUs.&#10; 4. How to call C functions from python code.&#10; 5. How to avoid race conditions between IEC, C and python code.&#10; 6. How to convert betweet different IEC types.&#10;"/>

<coordinateInfo>

<pageSize x="1024" y="1024"/>

<fbd>

<?xml version='1.0' encoding='utf-8'?>

<PyFile xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

<variables>

</variables>

<globals>

<xhtml:p><![CDATA[

def MyFunc(*args):

print args

]]></xhtml:p>

</globals>

<init>

timeout=None, outlimit=None, errlimit=None,

endlog=None, keyword=None, kill_it=False, cwd=None,

encoding=None, output_encoding=None):

self.logger = logger

if not isinstance(Command, list):

self.Command_str = Command

v = v.decode(self.output_encoding)

self.outdata.append(v)

self.outlen += 1

self.logger.write(v)

if (self.keyword and v.find(self.keyword) != -1) or (self.outlimit and self.outlen > self.outlimit):

self.endlog()

v = v.decode(self.output_encoding)

self.errdata.append(v)

self.errlen += 1

self.logger.write_warning(v)

if self.errlimit and self.errlen > self.errlimit:

self.endlog()