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

   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):

   116

   117

        def _onchange(var):

   118

            return repr(var.getonchange()) \

   119

                if var.getonchange() else None

   120

   121

        pyextname = self.CTNName()

   122

        varinfos = map(

   123

            lambda variable: {

   124

                "name": variable.getname(),

   125

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

   126

                "onchangecode": _onchangecode(variable),

   127

                "onchange": _onchange(variable),

   128

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

   129

                "configname": configname.upper(),

   130

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

   131

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

   132

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

   133

                "pyextname": pyextname

   134

            },

   135

            self.CodeFile.variables.variable)

   139

        # python side PLC global variables access stub

   140

        globalstubs = "\n".join([

   141

            """\

   142

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

   143

    TypeTranslator["%(IECtype)s"]

   144

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

   145

_PySafeGetPLCGlob_%(name)s.restype = None

   146

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

   147

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

   148

_PySafeSetPLCGlob_%(name)s.restype = None

   149

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

   150

_%(pyextname)sGlobalsDesc.append((

   151

    "%(name)s",

   152

    "%(IECtype)s",

   153

    %(initial)s,

   154

    %(desc)s,

   155

    %(onchange)s,

   156

    %(opts)s))

   157

""" % varinfo for varinfo in varinfos])

   158

   169

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

   170

        rtcalls = ""

   171

        for section in self.SECTIONS_NAMES:

   172

            if section != "globals":

   173

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

   174

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

   175

                if sectiontext:

   176

                    rtcalls += '    ' + \

   177

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

   178

                else:

   179

                    rtcalls += "    pass\n\n"

   180

   181

        globalsection = self.GetSection("globals")

   182

   183

        loc_dict = {

   184

            "pyextname": pyextname,

   185

            "globalstubs": globalstubs,

   186

            "globalsection": globalsection,

   187

            "rtcalls": rtcalls,

   191

        }

   192

   193

        PyFileContent = """\

   194

#!/usr/bin/env python

   195

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

   196

## Code generated by Beremiz python mixin confnode

   197

##

   198

   199

## Code for PLC global variable access

   200

from runtime.typemapping import TypeTranslator

   201

import ctypes

   207

_%(pyextname)sGlobalsDesc = []

   208

__ext_name__ = "%(pyextname)s"

   209

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

   210

%(globalstubs)s

   211

   212

## User code in "global" scope

   213

%(globalsection)s

   214

   215

## Beremiz python runtime calls

   216

%(rtcalls)s

   217

   228

del __ext_name__

   229

   230

""" % loc_dict

   231

   232

        # write generated content to python file

   233

        runtimefile_path = os.path.join(buildpath,

   234

                                        "runtime_%s.py" % location_str)

   235

        runtimefile = open(runtimefile_path, 'w')

   236

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

   237

        runtimefile.close()

   238

   239

        # C code for safe global variables access

   240

   241

        vardecfmt = """\

   242

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

   243

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

   244

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

   245

long __%(name)s_rlock = 0;

   246

long __%(name)s_wlock = 0;

   247

int __%(name)s_wbuffer_written = 0;

   248

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

   249

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

   250

    *pvalue = __%(name)s_rbuffer;

   251

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

   252

}

   253

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

   254

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

   255

    __%(name)s_wbuffer = *value;

   256

    __%(name)s_wbuffer_written = 1;

   257

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

   258

}

   259

   260

"""

   261

   262

        vardeconchangefmt = """\

   264

"""

   265

   266

        varretfmt = """\

   267

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

   268

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

   269

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

   270

            __%(name)s_wbuffer_written = 0;

   271

        }

   272

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

   273

    }

   274

"""

   275

        varpubfmt = """\

   276

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

   277

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

   278

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

   279

    }

   280

"""

   281

   282

        varpubonchangefmt = """\

   283

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

   284

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

   285

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

   286

            __%(name)s_rbuffer = tmp;

   290

        }

   291

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

   292

    }

   293

"""

   302

"""

   303

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

   304

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

   305

                            for varinfo in varinfos])

   306

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

   307

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

   308

                             varpubfmt) % varinfo

   309

                            for varinfo in varinfos])

   311

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

   312

   315

        loc_dict = {

   316

            "vardec": vardec,

   317

            "varret": varret,

   318

            "varpub": varpub,

   319

            "location_str": location_str,

   324

        }

   325

   326

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

   327

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

   328

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

   329

        PyCFileContent = """\

   330

/*

   331

 * Code generated by Beremiz py_ext confnode

   332

 * for safe global variables access

   333

 */

   334

#include "iec_types_all.h"

   335

#include "POUS.h"

   336

#include "config.h"

   337

#include "beremiz.h"

   338

   341

/* User variables reference */

   342

%(vardec)s

   343

   344

/* Beremiz confnode functions */

   345

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

   350

    return 0;

   351

}

   352

   353

void __cleanup_%(location_str)s(void){

   354

}

   355

   356

void __retrieve_%(location_str)s(void){

   357

%(varret)s

   358

}

   359

   360

void __publish_%(location_str)s(void){

   362

%(varpub)s

   376

""" % loc_dict

   377

   378

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

   379

        pycfile = open(Gen_PyCfile_path, 'w')

   380

        pycfile.write(PyCFileContent)

   381

        pycfile.close()

   382

   383

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

   384

            self.GetCTRoot().GetIECLibPath())

   385

   386

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   387

                "",

   388

                True,

   389

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