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 CTNGlobalInstances(self):

    99

        variables = self.CodeFileVariables(self.CodeFile)

   100

        ret = [(variable.getname(),

   101

                variable.gettype(),

   102

                variable.getinitial())

   103

               for variable in variables]

   106

        return ret

   107

   108

    def CTNGenerate_C(self, buildpath, locations):

   109

        # location string for that CTN

   110

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

   111

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

   112

   113

        def _onchangecode(var):

   115

   116

        def _onchange(var):

   117

            return repr(var.getonchange()) \

   118

                if var.getonchange() else None

   119

   120

        pyextname = self.CTNName()

   121

        varinfos = map(

   122

            lambda variable: {

   123

                "name": variable.getname(),

   124

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

   125

                "onchangecode": _onchangecode(variable),

   126

                "onchange": _onchange(variable),

   127

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

   128

                "configname": configname.upper(),

   129

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

   130

                "IECtype": self.GetCTRoot().GetBaseType(variable.gettype()),

   131

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

   132

                "pyextname": pyextname

   133

            },

   134

            self.CodeFile.variables.variable)

   138

        # python side PLC global variables access stub

   139

        globalstubs = "\n".join([

   140

            """\

   141

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

   142

    TypeTranslator["%(IECtype)s"]

   143

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

   144

_PySafeGetPLCGlob_%(name)s.restype = None

   145

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

   146

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

   147

_PySafeSetPLCGlob_%(name)s.restype = None

   148

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

   149

_%(pyextname)sGlobalsDesc.append((

   150

    "%(name)s",

   151

    "%(IECtype)s",

   152

    %(initial)s,

   153

    %(desc)s,

   154

    %(onchange)s,

   155

    %(opts)s))

   156

""" % varinfo for varinfo in varinfos])

   157

   166

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

   167

        rtcalls = ""

   168

        for section in self.SECTIONS_NAMES:

   169

            if section != "globals":

   170

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

   171

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

   172

                if sectiontext:

   173

                    rtcalls += '    ' + \

   174

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

   175

                else:

   176

                    rtcalls += "    pass\n\n"

   177

   178

        globalsection = self.GetSection("globals")

   179

   180

        loc_dict = {

   181

            "pyextname": pyextname,

   182

            "globalstubs": globalstubs,

   183

            "globalsection": globalsection,

   184

            "rtcalls": rtcalls,

   188

        }

   189

   190

        PyFileContent = """\

   191

#!/usr/bin/env python

   192

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

   193

## Code generated by Beremiz python mixin confnode

   194

##

   195

   196

## Code for PLC global variable access

   197

from runtime.typemapping import TypeTranslator

   198

import ctypes

   204

_%(pyextname)sGlobalsDesc = []

   205

__ext_name__ = "%(pyextname)s"

   206

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

   207

%(globalstubs)s

   208

   209

## User code in "global" scope

   210

%(globalsection)s

   211

   212

## Beremiz python runtime calls

   213

%(rtcalls)s

   214

   225

del __ext_name__

   226

   227

""" % loc_dict

   228

   229

        # write generated content to python file

   230

        runtimefile_path = os.path.join(buildpath,

   231

                                        "runtime_%s.py" % location_str)

   232

        runtimefile = open(runtimefile_path, 'w')

   233

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

   234

        runtimefile.close()

   235

   236

        # C code for safe global variables access

   237

   238

        vardecfmt = """\

   239

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

   240

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

   241

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

   242

long __%(name)s_rlock = 0;

   243

long __%(name)s_wlock = 0;

   244

int __%(name)s_wbuffer_written = 0;

   245

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

   246

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

   247

    *pvalue = __%(name)s_rbuffer;

   248

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

   249

}

   250

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

   251

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

   252

    __%(name)s_wbuffer = *value;

   253

    __%(name)s_wbuffer_written = 1;

   254

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

   255

}

   256

   257

"""

   258

   259

        vardeconchangefmt = """\

   261

"""

   262

   263

        varretfmt = """\

   264

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

   265

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

   266

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

   267

            __%(name)s_wbuffer_written = 0;

   268

        }

   269

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

   270

    }

   271

"""

   272

        varpubfmt = """\

   273

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

   274

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

   275

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

   276

    }

   277

"""

   278

   279

        varpubonchangefmt = """\

   280

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

   281

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

   282

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

   283

            __%(name)s_rbuffer = tmp;

   287

        }

   288

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

   289

    }

   290

"""

   299

"""

   300

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

   301

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

   302

                            for varinfo in varinfos])

   303

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

   304

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

   305

                             varpubfmt) % varinfo

   306

                            for varinfo in varinfos])

   308

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

   309

   312

        loc_dict = {

   313

            "vardec": vardec,

   314

            "varret": varret,

   315

            "varpub": varpub,

   316

            "location_str": location_str,

   321

        }

   322

   323

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

   324

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

   325

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

   326

        PyCFileContent = """\

   327

/*

   328

 * Code generated by Beremiz py_ext confnode

   329

 * for safe global variables access

   330

 */

   331

#include "iec_types_all.h"

   332

#include "POUS.h"

   333

#include "config.h"

   334

#include "beremiz.h"

   335

   338

/* User variables reference */

   339

%(vardec)s

   340

   341

/* Beremiz confnode functions */

   342

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

   347

    return 0;

   348

}

   349

   350

void __cleanup_%(location_str)s(void){

   351

}

   352

   353

void __retrieve_%(location_str)s(void){

   354

%(varret)s

   355

}

   356

   357

void __publish_%(location_str)s(void){

   359

%(varpub)s

   373

""" % loc_dict

   374

   375

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

   376

        pycfile = open(Gen_PyCfile_path, 'w')

   377

        pycfile.write(PyCFileContent)

   378

        pycfile.close()

   379

   380

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

   381

            self.GetCTRoot().GetIECLibPath())

   382

   383

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   384

                "",

   385

                True,

   386

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