#!/usr/bin/env python

# -*- coding: utf-8 -*-

import sys

import os

import getopt

import __builtin__

import time

# On Windows install schema, we compute path to beremiz

# relative to path to python folder (sys.path[0] in that case)

# note: beware that wx import messes up sys.path[0]

_dist_folder = os.path.split(sys.path[0])[0]

_beremiz_folder = os.path.join(_dist_folder, "beremiz")

# Then we add it to sys.path, to make "import Beremiz" possible

sys.path.append(_beremiz_folder)

import wx

from util.BitmapLibrary import AddBitmapFolder

# Path of directory containing current python file

_lpcmanager_path = os.path.split(__file__)[0]

from LPCArch import PLC_module, SetLPCArch

class LPCManagerLauncher(BeremizIDELauncher):

def __init__(self):

BeremizIDELauncher.__init__(self)

self.arch = None

self.port = None

self.extensions = [os.path.join(_lpcmanager_path, "extention.py")]

self.modules.extend([

"LPCBeremiz",

"StdoutPseudoFile",

"LPCProjectController",

"LPCCommand"])

def Usage(self):

print("\nUsage of LPCManager.py :")

print("\n %s Projectpath Buildpath port arch\n" % sys.argv[0])

def ProcessCommandLineArgs(self):

# Command line arguments parsing

try:

opts, args = getopt.getopt(sys.argv[1:], "h", ["help"])

except getopt.GetoptError:

# print help information and exit:

self.Usage()

sys.exit(2)

# asking for help causes exit

for o, a in opts:

if o in ("-h", "--help"):

self.Usage()

sys.exit()

if len(args) != 4 :

self.Usage()

sys.exit()

else:

self.projectOpen = args[0]

self.buildpath = args[1]

try:

self.port = int(args[2])

except:

self.Usage()

sys.exit()

self.arch = args[3]

SetLPCArch(self.arch)

# overload with exacltly same code, but this is intended.

# we want extensions to use globals of this module, not Beremiz.py

def globals(self):

return globals()

def CreateUI(self):

CMDpipe = self.StdoutPseudoFile.StdoutPseudoFile(self.port, self.debug)

if self.projectOpen is not None:

self.projectOpen = self.BeremizIDE.DecodeFileSystemPath(self.projectOpen, False)

CTR = self.LPCProjectController.LPCProjectController(

None, CMDpipe, self.buildpath, self.arch)

if self.projectOpen is not None and os.path.isdir(self.projectOpen):

result = CTR.LoadProject(self.projectOpen)

if result:

CMDpipe.write("Error: Invalid project directory", result)

else:

CMDpipe.write("Error: No such file or directory")

lpcberemiz_cmd = LPCCommand(CTR, CMDpipe)

cmd_thread = Thread(target=lpcberemiz_cmd.cmdloop)

cmd_thread.start()

# TODO: join() when exiting

self.frame = self.LPCBeremiz.LPCBeremiz(None, ctr=CTR)

def ShowUI(self):

# the "Show" command from composer does it instead

pass

def CreateApplication(self):

# Create app usual way

BeremizIDELauncher.CreateApplication(self)

# Add LPCmanager's image folder to searched ones.

AddBitmapFolder(os.path.join(_lpcmanager_path, "images"))

# from controls.LogViewer import LogViewer

from VariableExporter import VariableWriter

from PLCControler import PLCControler, ITEMS_UNEDITABLE, ITEM_POU

from wx.lib.scrolledpanel import ScrolledPanel

from types import MethodType

from IDEFrame import IDEFrame

from dialogs import SearchInProjectDialog

from controls import TextCtrlAutoComplete

from py_ext import PythonFileCTNMixin

from plcopen.structures import TestIdentifier, IDENTIFIER_MODEL

def CTNGenerate_C(self, buildpath, locations):

# location string for that CTN

location_str = "_".join(map(lambda x: str(x),

self.GetCurrentLocation()))

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

pyextname = self.CTNName()

varinfos = map(lambda variable: {

"name": variable.getname(),

"desc": repr(variable.getdesc()),

"onchangecode": '"' + variable.getonchange() + \

"('" + variable.getname() + "')\"" \

if variable.getonchange() else '""',

"onchange": repr(variable.getonchange()) \

if variable.getonchange() else None,

"opts": repr(variable.getopts()),

"configname": configname.upper(),

"uppername": variable.getname().upper(),

"IECtype": variable.gettype(),

"initial": repr(variable.getinitial()),

"pyextname": pyextname},

self.CodeFile.variables.variable)

# python side PLC global variables access stub

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

_%(name)s_ctype, _%(name)s_unpack, _%(name)s_pack = \\

TypeTranslator["%(IECtype)s"]

_PySafeGetPLCGlob_%(name)s = PLCBinary.__SafeGetPLCGlob_%(name)s

_PySafeGetPLCGlob_%(name)s.restype = None

_PySafeGetPLCGlob_%(name)s.argtypes = [ctypes.POINTER(_%(name)s_ctype)]

_PySafeSetPLCGlob_%(name)s = PLCBinary.__SafeSetPLCGlob_%(name)s

_PySafeSetPLCGlob_%(name)s.restype = None

_PySafeSetPLCGlob_%(name)s.argtypes = [ctypes.POINTER(_%(name)s_ctype)]

_%(pyextname)sGlobalsDesc.append((

"%(name)s",

"%(IECtype)s",

%(initial)s,

%(desc)s,

%(onchange)s,

%(opts)s))

""" % varinfo

for varinfo in varinfos])

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

rtcalls = ""

for section in self.SECTIONS_NAMES:

if section != "globals":

rtcalls += "def _runtime_%s_%s():\n" % (location_str, section)

sectiontext = self.GetSection(section).strip()

if sectiontext:

rtcalls += ' ' + \

sectiontext.replace('\n', '\n ') + "\n\n"

else:

rtcalls += " pass\n\n"

globalsection = self.GetSection("globals")

PyFileContent = """\

#!/usr/bin/env python

# -*- coding: utf-8 -*-

## Code generated by Beremiz python mixin confnode

##

## Code for PLC global variable access

from targets.typemapping import TypeTranslator

import ctypes

_%(pyextname)sGlobalsDesc = []

__ext_name__ = "%(pyextname)s"

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

%(globalstubs)s

## User code in "global" scope

%(globalsection)s

## Beremiz python runtime calls

%(rtcalls)s

del __ext_name__

""" % locals()

# write generated content to python file

runtimefile_path = os.path.join(buildpath,

"runtime_%s.py" % location_str)

runtimefile = open(runtimefile_path, 'w')

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

runtimefile.close()

# C code for safe global variables access

vardecfmt = """\

extern __IEC_%(IECtype)s_t %(configname)s__%(uppername)s;

IEC_%(IECtype)s __%(name)s_rbuffer = __INIT_%(IECtype)s;

IEC_%(IECtype)s __%(name)s_wbuffer;

long __%(name)s_rlock = 0;

long __%(name)s_wlock = 0;

int __%(name)s_wbuffer_written = 0;

void __SafeGetPLCGlob_%(name)s(IEC_%(IECtype)s *pvalue){

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

*pvalue = __%(name)s_rbuffer;

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

}

void __SafeSetPLCGlob_%(name)s(IEC_%(IECtype)s *value){

while(AtomicCompareExchange(&__%(name)s_wlock, 0, 1));

__%(name)s_wbuffer = *value;

__%(name)s_wbuffer_written = 1;

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

}

"""

vardeconchangefmt = """\

PYTHON_POLL* __%(name)s_notifier;

"""

varretfmt = """\

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

if(__%(name)s_wbuffer_written == 1){

%(configname)s__%(uppername)s.value = __%(name)s_wbuffer;

__%(name)s_wbuffer_written = 0;

}

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

}

"""

varpubfmt = """\

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

__%(name)s_rbuffer = __GET_VAR(%(configname)s__%(uppername)s);

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

}

"""

varpubonchangefmt = """\

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

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

if(__%(name)s_rbuffer != tmp){

__%(name)s_rbuffer = %(configname)s__%(uppername)s.value;

PYTHON_POLL_body__(__%(name)s_notifier);

}

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

}

"""

varinitonchangefmt = """\

__%(name)s_notifier = __GET_GLOBAL_ON%(uppername)sCHANGE();

__SET_VAR(__%(name)s_notifier->,TRIG,,__BOOL_LITERAL(TRUE));

__SET_VAR(__%(name)s_notifier->,CODE,,__STRING_LITERAL(%(onchangelen)d,%(onchangecode)s));

"""

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

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

for varinfo in varinfos])

varret = "\n".join([varretfmt % varinfo for varinfo in varinfos])

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

varpubfmt) % varinfo

for varinfo in varinfos])

varinit = "\n".join([varinitonchangefmt % dict(

onchangelen=len(varinfo["onchangecode"]), **varinfo)

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

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

# "config.h". User cannot change config name, but project imported

# or created in older beremiz vesion could use different name.

PyCFileContent = """\

/*

* Code generated by Beremiz py_ext confnode

* for safe global variables access

*/

#include "iec_types_all.h"

#include "POUS.h"

#include "config.h"

#include "beremiz.h"

/* User variables reference */

%(vardec)s

/* Beremiz confnode functions */

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

%(varinit)s

return 0;

}

void __cleanup_%(location_str)s(void){

}

void __retrieve_%(location_str)s(void){

%(varret)s

}

void __publish_%(location_str)s(void){

%(varpub)s

}

""" % locals()

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

pycfile = open(Gen_PyCfile_path, 'w')

pycfile.write(PyCFileContent)

pycfile.close()

matiec_CFLAGS = '"-I%s"' % os.path.abspath(

self.GetCTRoot().GetIECLibPath())

return ([(Gen_PyCfile_path, matiec_CFLAGS)],

"",

True,

("runtime_%s.py" % location_str, file(runtimefile_path, "rb")))

PythonFileCTNMixin.CTNGenerate_C = CTNGenerate_C

if __name__ == '__main__':

lpcmanager = LPCManagerLauncher()

lpcmanager.Start()