1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

# This program is free software; you can redistribute it and/or

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

# of the License, or (at your option) any later version.

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

# You should have received a copy of the GNU General Public License

    23

# along with this program; if not, write to the Free Software

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    28

from lxml import etree

    29

import util.paths as paths

    30

    31

from xmlclass import GenerateParserFromXSD

    32

    33

from CodeFileTreeNode import CodeFile

    34

from PythonEditor import PythonEditor

    35

    36

class PythonFileCTNMixin(CodeFile):

    37

    38

    CODEFILE_NAME = "PyFile"

    39

    SECTIONS_NAMES = [

    40

        "globals",

    41

        "init",

    42

        "cleanup",

    43

        "start",

    44

        "stop"]

    45

    EditorType = PythonEditor

    46

    47

    def __init__(self):

    48

        CodeFile.__init__(self)

    49

    50

        filepath = self.PythonFileName()

    51

    52

        if os.path.isfile(filepath):

    53

            PythonParser = GenerateParserFromXSD(paths.AbsNeighbourFile(__file__, "py_ext_xsd.xsd"))

    54

    55

            xmlfile = open(filepath, 'r')

    56

            pythonfile_xml = xmlfile.read()

    57

            xmlfile.close()

    58

    59

            pythonfile_xml = pythonfile_xml.replace(

    60

                'xmlns="http://www.w3.org/2001/XMLSchema"',

    61

                'xmlns:xhtml="http://www.w3.org/1999/xhtml"')

    62

            for cre, repl in [

    63

                (re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["),

    64

                (re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]:

    65

                pythonfile_xml = cre.sub(repl, pythonfile_xml)

    66

    67

            try:

    68

                python_code, error = PythonParser.LoadXMLString(pythonfile_xml)

    69

                if error is None:

    70

                    self.CodeFile.globals.setanyText(python_code.getanyText())

    71

                    os.remove(filepath)

    72

                    self.CreateCodeFileBuffer(False)

    73

                    self.OnCTNSave()

    74

            except Exception, exc:

    75

                error = unicode(exc)

    76

    77

            if error is not None:

    78

                self.GetCTRoot().logger.write_error(

    79

                    _("Couldn't import old %s file.") % self.CTNName())

    80

    81

    def CodeFileName(self):

    82

        return os.path.join(self.CTNPath(), "pyfile.xml")

    83

    84

    def PythonFileName(self):

    85

        return os.path.join(self.CTNPath(), "py_ext.xml")

    86

    87

    PreSectionsTexts = {}

    88

    PostSectionsTexts = {}

    89

    def GetSection(self,section):

    90

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

    91

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

    92

               self.PostSectionsTexts.get(section,"")

    93

    94

    def CTNGenerate_C(self, buildpath, locations):

    95

        # location string for that CTN

    96

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

    97

                                self.GetCurrentLocation()))

    98

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

    99

   100

        pyextname = self.CTNName()

   101

        varinfos = map(lambda variable : {

   102

                    "name": variable.getname(),

   103

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

   104

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

   105

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

   106

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

   107

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

   108

                                 if variable.getonchange() else None,

   109

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

   110

                    "configname" : configname.upper(),

   111

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

   112

                    "IECtype" : variable.gettype(),

   113

                    "pyextname" :pyextname},

   114

                    self.CodeFile.variables.variable)

   115

        # python side PLC global variables access stub

   116

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

   117

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

   118

    TypeTranslator["%(IECtype)s"]

   119

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

   120

_PySafeGetPLCGlob_%(name)s.restype = None

   121

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

   122

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

   123

_PySafeSetPLCGlob_%(name)s.restype = None

   124

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

   125

_%(pyextname)sGlobalsDesc.append((

   126

    "%(name)s",

   127

    "%(IECtype)s",

   128

    %(desc)s,

   129

    %(onchange)s,

   130

    %(opts)s))

   131

""" % varinfo

   132

      for varinfo in varinfos])

   133

   134

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

   135

        rtcalls = ""

   136

        for section in self.SECTIONS_NAMES:

   137

            if section != "globals":

   138

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

   139

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

   140

                if sectiontext:

   141

                    rtcalls += '    ' + \

   142

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

   143

                else:

   144

                    rtcalls += "    pass\n\n"

   145

   146

        globalsection = self.GetSection("globals")

   147

   148

        PyFileContent = """\

   149

#!/usr/bin/env python

   150

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

   151

## Code generated by Beremiz python mixin confnode

   152

##

   153

   154

## Code for PLC global variable access

   155

from targets.typemapping import TypeTranslator

   156

import ctypes

   157

_%(pyextname)sGlobalsDesc = []

   158

__ext_name__ = "%(pyextname)s"

   159

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

   160

%(globalstubs)s

   161

   162

## User code in "global" scope

   163

%(globalsection)s

   164

   165

## Beremiz python runtime calls

   166

%(rtcalls)s

   167

   168

del __ext_name__

   169

   170

""" % locals()

   171

   172

        # write generated content to python file

   173

        runtimefile_path = os.path.join(buildpath,

   174

            "runtime_%s.py"%location_str)

   175

        runtimefile = open(runtimefile_path, 'w')

   176

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

   177

        runtimefile.close()

   178

   179

        # C code for safe global variables access

   180

   181

        vardecfmt = """\

   182

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

   183

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

   184

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

   185

long __%(name)s_rlock = 0;

   186

long __%(name)s_wlock = 0;

   187

int __%(name)s_wbuffer_written = 0;

   188

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

   189

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

   190

    *pvalue = __%(name)s_rbuffer;

   191

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

   192

}

   193

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

   194

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

   195

    __%(name)s_wbuffer = *value;

   196

    __%(name)s_wbuffer_written = 1;

   197

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

   198

}

   199

   200

"""

   201

   202

        vardeconchangefmt = """\

   203

PYTHON_POLL* __%(name)s_notifier;

   204

"""

   205

   206

        varretfmt = """\

   207

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

   208

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

   209

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

   210

            __%(name)s_wbuffer_written = 0;

   211

        }

   212

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

   213

    }

   214

"""

   215

        varpubfmt = """\

   216

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

   217

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

   218

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

   219

    }

   220

"""

   221

   222

        varpubonchangefmt = """\

   223

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

   224

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

   225

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

   226

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

   227

            PYTHON_POLL_body__(__%(name)s_notifier);

   228

        }

   229

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

   230

    }

   231

"""

   232

        varinitonchangefmt = """\

   233

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

   234

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

   235

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

   236

"""

   237

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

   238

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

   239

                            for varinfo in varinfos])

   240

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

   241

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

   242

                             varpubfmt) % varinfo

   243

                            for varinfo in varinfos])

   244

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

   245

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

   246

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

   247

   248

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

   249

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

   250

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

   251

        PyCFileContent = """\

   252

/*

   253

 * Code generated by Beremiz py_ext confnode

   254

 * for safe global variables access

   255

 */

   256

#include "iec_types_all.h"

   257

#include "POUS.h"

   258

#include "config.h"

   259

#include "beremiz.h"

   260

   261

/* User variables reference */

   262

%(vardec)s

   263

   264

/* Beremiz confnode functions */

   265

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

   266

%(varinit)s

   267

    return 0;

   268

}

   269

   270

void __cleanup_%(location_str)s(void){

   271

}

   272

   273

void __retrieve_%(location_str)s(void){

   274

%(varret)s

   275

}

   276

   277

void __publish_%(location_str)s(void){

   278

%(varpub)s

   279

}

   280

""" % locals()

   281

   282

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

   283

        pycfile = open(Gen_PyCfile_path,'w')

   284

        pycfile.write(PyCFileContent)

   285

        pycfile.close()

   286

   287

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

   288

            self.GetCTRoot().GetIECLibPath())

   289

   290

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   291

                "",

   292

                True,

   293

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

   294