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

    26

    27

from __future__ import absolute_import

    28

import os

    29

import re

    30

import util.paths as paths

    31

    32

from xmlclass import GenerateParserFromXSD

    33

    34

from CodeFileTreeNode import CodeFile

    35

from py_ext.PythonEditor import PythonEditor

    36

    37

    38

class PythonFileCTNMixin(CodeFile):

    39

    40

    CODEFILE_NAME = "PyFile"

    41

    SECTIONS_NAMES = [

    42

        "globals",

    43

        "init",

    44

        "cleanup",

    45

        "start",

    46

        "stop"]

    47

    EditorType = PythonEditor

    48

    49

    def __init__(self):

    50

        CodeFile.__init__(self)

    51

    52

        filepath = self.PythonFileName()

    53

    54

        if os.path.isfile(filepath):

    55

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

    56

    57

            xmlfile = open(filepath, 'r')

    58

            pythonfile_xml = xmlfile.read()

    59

            xmlfile.close()

    60

    61

            pythonfile_xml = pythonfile_xml.replace(

    62

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

    63

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

    64

            for cre, repl in [

    65

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

    66

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

    67

                pythonfile_xml = cre.sub(repl, pythonfile_xml)

    68

    69

            try:

    70

                python_code, error = PythonParser.LoadXMLString(pythonfile_xml)

    71

                if error is None:

    72

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

    73

                    os.remove(filepath)

    74

                    self.CreateCodeFileBuffer(False)

    75

                    self.OnCTNSave()

    77

                error = unicode(exc)

    78

    79

            if error is not None:

    80

                self.GetCTRoot().logger.write_error(

    81

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

    82

    83

    def CodeFileName(self):

    84

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

    85

    86

    def PythonFileName(self):

    87

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

    88

    89

    PreSectionsTexts = {}

    90

    PostSectionsTexts = {}

    91

    92

    def GetSection(self, section):

    93

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

    94

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

    95

               self.PostSectionsTexts.get(section, "")

    96

    97

    def CTNGenerate_C(self, buildpath, locations):

    98

        # location string for that CTN

    99

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

   100

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

   101

   102

        def _onchangecode(var):

   103

            return '"' + var.getonchange() + \

   104

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

   105

                if var.getonchange() else '""'

   106

   107

        def _onchange(var):

   108

            return repr(var.getonchange()) \

   109

                if var.getonchange() else None

   110

   111

        pyextname = self.CTNName()

   112

        varinfos = map(

   113

            lambda variable: {

   114

                "name": variable.getname(),

   115

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

   116

                "onchangecode": _onchangecode(variable),

   117

                "onchange": _onchange(variable),

   118

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

   119

                "configname": configname.upper(),

   120

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

   121

                "IECtype": variable.gettype(),

   122

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

   123

                "pyextname": pyextname

   124

            },

   125

            self.CodeFile.variables.variable)

   126

        # python side PLC global variables access stub

   127

        globalstubs = "\n".join([

   128

            """\

   129

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

   130

    TypeTranslator["%(IECtype)s"]

   131

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

   132

_PySafeGetPLCGlob_%(name)s.restype = None

   133

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

   134

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

   135

_PySafeSetPLCGlob_%(name)s.restype = None

   136

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

   137

_%(pyextname)sGlobalsDesc.append((

   138

    "%(name)s",

   139

    "%(IECtype)s",

   140

    %(initial)s,

   141

    %(desc)s,

   142

    %(onchange)s,

   143

    %(opts)s))

   144

""" % varinfo for varinfo in varinfos])

   145

   146

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

   147

        rtcalls = ""

   148

        for section in self.SECTIONS_NAMES:

   149

            if section != "globals":

   150

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

   151

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

   152

                if sectiontext:

   153

                    rtcalls += '    ' + \

   154

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

   155

                else:

   156

                    rtcalls += "    pass\n\n"

   157

   158

        globalsection = self.GetSection("globals")

   159

   160

        loc_dict = {

   161

            "pyextname": pyextname,

   162

            "globalstubs": globalstubs,

   163

            "globalsection": globalsection,

   164

            "rtcalls": rtcalls,

   165

        }

   166

   167

        PyFileContent = """\

   168

#!/usr/bin/env python

   169

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

   170

## Code generated by Beremiz python mixin confnode

   171

##

   172

   173

## Code for PLC global variable access

   174

from runtime.typemapping import TypeTranslator

   175

import ctypes

   176

_%(pyextname)sGlobalsDesc = []

   177

__ext_name__ = "%(pyextname)s"

   178

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

   179

%(globalstubs)s

   180

   181

## User code in "global" scope

   182

%(globalsection)s

   183

   184

## Beremiz python runtime calls

   185

%(rtcalls)s

   186

   187

del __ext_name__

   188

   189

""" % loc_dict

   190

   191

        # write generated content to python file

   192

        runtimefile_path = os.path.join(buildpath,

   193

                                        "runtime_%s.py" % location_str)

   194

        runtimefile = open(runtimefile_path, 'w')

   195

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

   196

        runtimefile.close()

   197

   198

        # C code for safe global variables access

   199

   200

        vardecfmt = """\

   201

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

   202

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

   203

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

   204

long __%(name)s_rlock = 0;

   205

long __%(name)s_wlock = 0;

   206

int __%(name)s_wbuffer_written = 0;

   207

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

   208

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

   209

    *pvalue = __%(name)s_rbuffer;

   210

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

   211

}

   212

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

   213

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

   214

    __%(name)s_wbuffer = *value;

   215

    __%(name)s_wbuffer_written = 1;

   216

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

   217

}

   218

   219

"""

   220

   221

        vardeconchangefmt = """\

   222

PYTHON_POLL* __%(name)s_notifier;

   223

"""

   224

   225

        varretfmt = """\

   226

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

   227

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

   228

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

   229

            __%(name)s_wbuffer_written = 0;

   230

        }

   231

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

   232

    }

   233

"""

   234

        varpubfmt = """\

   235

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

   236

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

   237

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

   238

    }

   239

"""

   240

   241

        varpubonchangefmt = """\

   242

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

   243

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

   244

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

   245

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

   246

            PYTHON_POLL_body__(__%(name)s_notifier);

   247

        }

   248

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

   249

    }

   250

"""

   251

        varinitonchangefmt = """\

   252

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

   253

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

   254

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

   255

"""

   256

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

   257

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

   258

                            for varinfo in varinfos])

   259

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

   260

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

   261

                             varpubfmt) % varinfo

   262

                            for varinfo in varinfos])

   263

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

   264

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

   265

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

   266

   267

        loc_dict = {

   268

            "vardec": vardec,

   269

            "varinit": varinit,

   270

            "varret": varret,

   271

            "varpub": varpub,

   272

            "location_str": location_str,

   273

        }

   274

   275

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

   276

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

   277

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

   278

        PyCFileContent = """\

   279

/*

   280

 * Code generated by Beremiz py_ext confnode

   281

 * for safe global variables access

   282

 */

   283

#include "iec_types_all.h"

   284

#include "POUS.h"

   285

#include "config.h"

   286

#include "beremiz.h"

   287

   288

/* User variables reference */

   289

%(vardec)s

   290

   291

/* Beremiz confnode functions */

   292

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

   293

%(varinit)s

   294

    return 0;

   295

}

   296

   297

void __cleanup_%(location_str)s(void){

   298

}

   299

   300

void __retrieve_%(location_str)s(void){

   301

%(varret)s

   302

}

   303

   304

void __publish_%(location_str)s(void){

   305

%(varpub)s

   306

}

   307

""" % loc_dict

   308

   309

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

   310

        pycfile = open(Gen_PyCfile_path, 'w')

   311

        pycfile.write(PyCFileContent)

   312

        pycfile.close()

   313

   314

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

   315

            self.GetCTRoot().GetIECLibPath())

   316

   317

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   318

                "",

   319

                True,

   320

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