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

from builtins import str as text

    31

    32

import util.paths as paths

    33

from xmlclass import GenerateParserFromXSD

    34

    35

from CodeFileTreeNode import CodeFile

    36

from py_ext.PythonEditor import PythonEditor

    37

    38

    39

class PythonFileCTNMixin(CodeFile):

    40

    41

    CODEFILE_NAME = "PyFile"

    42

    SECTIONS_NAMES = [

    43

        "globals",

    44

        "init",

    45

        "cleanup",

    46

        "start",

    47

        "stop"]

    48

    EditorType = PythonEditor

    49

    50

    def __init__(self):

    51

        CodeFile.__init__(self)

    52

    53

        filepath = self.PythonFileName()

    54

    55

        if os.path.isfile(filepath):

    56

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

    57

    58

            xmlfile = open(filepath, 'r')

    59

            pythonfile_xml = xmlfile.read()

    60

            xmlfile.close()

    61

    62

            pythonfile_xml = pythonfile_xml.replace(

    63

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

    64

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

    65

            for cre, repl in [

    66

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

    67

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

    68

                pythonfile_xml = cre.sub(repl, pythonfile_xml)

    69

    70

            try:

    71

                python_code, error = PythonParser.LoadXMLString(pythonfile_xml)

    72

                if error is None:

    73

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

    74

                    os.remove(filepath)

    75

                    self.CreateCodeFileBuffer(False)

    76

                    self.OnCTNSave()

    77

            except Exception as exc:

    78

                error = text(exc)

    79

    80

            if error is not None:

    81

                self.GetCTRoot().logger.write_error(

    82

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

    83

    84

    def CodeFileName(self):

    85

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

    86

    87

    def PythonFileName(self):

    88

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

    89

    90

    PreSectionsTexts = {}

    91

    PostSectionsTexts = {}

    92

    93

    def GetSection(self, section):

    94

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

    95

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

    96

               self.PostSectionsTexts.get(section, "")

    97

    98

    def CTNGenerate_C(self, buildpath, locations):

    99

        # location string for that CTN

   100

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

   101

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

   102

   103

        def _onchangecode(var):

   104

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

   105

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

   106

                if var.getonchange() else '""'

   107

   108

        def _onchange(var):

   109

            return repr(var.getonchange()) \

   110

                if var.getonchange() else None

   111

   112

        pyextname = self.CTNName()

   113

        varinfos = map(

   114

            lambda variable: {

   115

                "name": variable.getname(),

   116

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

   117

                "onchangecode": _onchangecode(variable),

   118

                "onchange": _onchange(variable),

   119

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

   120

                "configname": configname.upper(),

   121

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

   122

                "IECtype": variable.gettype(),

   123

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

   124

                "pyextname": pyextname

   125

            },

   126

            self.CodeFile.variables.variable)

   127

        # python side PLC global variables access stub

   128

        globalstubs = "\n".join([

   129

            """\

   130

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

   131

    TypeTranslator["%(IECtype)s"]

   132

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

   133

_PySafeGetPLCGlob_%(name)s.restype = None

   134

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

   135

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

   136

_PySafeSetPLCGlob_%(name)s.restype = None

   137

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

   138

_%(pyextname)sGlobalsDesc.append((

   139

    "%(name)s",

   140

    "%(IECtype)s",

   141

    %(initial)s,

   142

    %(desc)s,

   143

    %(onchange)s,

   144

    %(opts)s))

   145

""" % varinfo for varinfo in varinfos])

   146

   147

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

   148

        rtcalls = ""

   149

        for section in self.SECTIONS_NAMES:

   150

            if section != "globals":

   151

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

   152

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

   153

                if sectiontext:

   154

                    rtcalls += '    ' + \

   155

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

   156

                else:

   157

                    rtcalls += "    pass\n\n"

   158

   159

        globalsection = self.GetSection("globals")

   160

   161

        loc_dict = {

   162

            "pyextname": pyextname,

   163

            "globalstubs": globalstubs,

   164

            "globalsection": globalsection,

   165

            "rtcalls": rtcalls,

   166

        }

   167

   168

        PyFileContent = """\

   169

#!/usr/bin/env python

   170

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

   171

## Code generated by Beremiz python mixin confnode

   172

##

   173

   174

## Code for PLC global variable access

   175

from runtime.typemapping import TypeTranslator

   176

import ctypes

   177

_%(pyextname)sGlobalsDesc = []

   178

__ext_name__ = "%(pyextname)s"

   179

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

   180

%(globalstubs)s

   181

   182

## User code in "global" scope

   183

%(globalsection)s

   184

   185

## Beremiz python runtime calls

   186

%(rtcalls)s

   187

   188

del __ext_name__

   189

   190

""" % loc_dict

   191

   192

        # write generated content to python file

   193

        runtimefile_path = os.path.join(buildpath,

   194

                                        "runtime_%s.py" % location_str)

   195

        runtimefile = open(runtimefile_path, 'w')

   196

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

   197

        runtimefile.close()

   198

   199

        # C code for safe global variables access

   200

   201

        vardecfmt = """\

   202

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

   203

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

   204

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

   205

long __%(name)s_rlock = 0;

   206

long __%(name)s_wlock = 0;

   207

int __%(name)s_wbuffer_written = 0;

   208

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

   209

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

   210

    *pvalue = __%(name)s_rbuffer;

   211

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

   212

}

   213

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

   214

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

   215

    __%(name)s_wbuffer = *value;

   216

    __%(name)s_wbuffer_written = 1;

   217

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

   218

}

   219

   220

"""

   221

   222

        vardeconchangefmt = """\

   223

PYTHON_POLL* __%(name)s_notifier;

   224

"""

   225

   226

        varretfmt = """\

   227

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

   228

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

   229

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

   230

            __%(name)s_wbuffer_written = 0;

   231

        }

   232

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

   233

    }

   234

"""

   235

        varpubfmt = """\

   236

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

   237

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

   238

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

   239

    }

   240

"""

   241

   242

        varpubonchangefmt = """\

   243

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

   244

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

   245

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

   246

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

   247

            PYTHON_POLL_body__(__%(name)s_notifier);

   248

        }

   249

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

   250

    }

   251

"""

   252

        varinitonchangefmt = """\

   253

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

   254

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

   255

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

   256

"""

   257

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

   258

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

   259

                            for varinfo in varinfos])

   260

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

   261

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

   262

                             varpubfmt) % varinfo

   263

                            for varinfo in varinfos])

   264

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

   265

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

   266

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

   267

   268

        loc_dict = {

   269

            "vardec": vardec,

   270

            "varinit": varinit,

   271

            "varret": varret,

   272

            "varpub": varpub,

   273

            "location_str": location_str,

   274

        }

   275

   276

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

   277

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

   278

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

   279

        PyCFileContent = """\

   280

/*

   281

 * Code generated by Beremiz py_ext confnode

   282

 * for safe global variables access

   283

 */

   284

#include "iec_types_all.h"

   285

#include "POUS.h"

   286

#include "config.h"

   287

#include "beremiz.h"

   288

   289

/* User variables reference */

   290

%(vardec)s

   291

   292

/* Beremiz confnode functions */

   293

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

   294

%(varinit)s

   295

    return 0;

   296

}

   297

   298

void __cleanup_%(location_str)s(void){

   299

}

   300

   301

void __retrieve_%(location_str)s(void){

   302

%(varret)s

   303

}

   304

   305

void __publish_%(location_str)s(void){

   306

%(varpub)s

   307

}

   308

""" % loc_dict

   309

   310

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

   311

        pycfile = open(Gen_PyCfile_path, 'w')

   312

        pycfile.write(PyCFileContent)

   313

        pycfile.close()

   314

   315

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

   316

            self.GetCTRoot().GetIECLibPath())

   317

   318

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   319

                "",

   320

                True,

   321

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