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

import os

    27

import re

    28

import util.paths as paths

    29

    30

from xmlclass import GenerateParserFromXSD

    31

    32

from CodeFileTreeNode import CodeFile

    33

from PythonEditor import PythonEditor

    34

    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

    90

    def GetSection(self, section):

    91

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

    92

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

    93

               self.PostSectionsTexts.get(section, "")

    94

    95

    def CTNGenerate_C(self, buildpath, locations):

    96

        # location string for that CTN

    97

        location_str = "_".join(map(str, 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

            """\

   118

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

   119

    TypeTranslator["%(IECtype)s"]

   120

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

   121

_PySafeGetPLCGlob_%(name)s.restype = None

   122

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

   123

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

   124

_PySafeSetPLCGlob_%(name)s.restype = None

   125

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

   126

_%(pyextname)sGlobalsDesc.append((

   127

    "%(name)s",

   128

    "%(IECtype)s",

   129

    %(desc)s,

   130

    %(onchange)s,

   131

    %(opts)s))

   132

""" % varinfo 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

        loc_dict = {

   149

            "pyextname": pyextname,

   150

            "globalstubs": globalstubs,

   151

            "globalsection": globalsection,

   152

            "rtcalls": rtcalls,

   153

        }

   154

   155

        PyFileContent = """\

   156

#!/usr/bin/env python

   157

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

   158

## Code generated by Beremiz python mixin confnode

   159

##

   160

   161

## Code for PLC global variable access

   162

from targets.typemapping import TypeTranslator

   163

import ctypes

   164

_%(pyextname)sGlobalsDesc = []

   165

__ext_name__ = "%(pyextname)s"

   166

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

   167

%(globalstubs)s

   168

   169

## User code in "global" scope

   170

%(globalsection)s

   171

   172

## Beremiz python runtime calls

   173

%(rtcalls)s

   174

   175

del __ext_name__

   176

   177

""" % loc_dict

   178

   179

        # write generated content to python file

   180

        runtimefile_path = os.path.join(buildpath,

   181

                                        "runtime_%s.py" % location_str)

   182

        runtimefile = open(runtimefile_path, 'w')

   183

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

   184

        runtimefile.close()

   185

   186

        # C code for safe global variables access

   187

   188

        vardecfmt = """\

   189

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

   190

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

   191

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

   192

long __%(name)s_rlock = 0;

   193

long __%(name)s_wlock = 0;

   194

int __%(name)s_wbuffer_written = 0;

   195

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

   196

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

   197

    *pvalue = __%(name)s_rbuffer;

   198

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

   199

}

   200

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

   201

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

   202

    __%(name)s_wbuffer = *value;

   203

    __%(name)s_wbuffer_written = 1;

   204

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

   205

}

   206

   207

"""

   208

   209

        vardeconchangefmt = """\

   210

PYTHON_POLL* __%(name)s_notifier;

   211

"""

   212

   213

        varretfmt = """\

   214

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

   215

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

   216

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

   217

            __%(name)s_wbuffer_written = 0;

   218

        }

   219

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

   220

    }

   221

"""

   222

        varpubfmt = """\

   223

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

   224

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

   225

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

   226

    }

   227

"""

   228

   229

        varpubonchangefmt = """\

   230

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

   231

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

   232

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

   233

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

   234

            PYTHON_POLL_body__(__%(name)s_notifier);

   235

        }

   236

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

   237

    }

   238

"""

   239

        varinitonchangefmt = """\

   240

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

   241

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

   242

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

   243

"""

   244

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

   245

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

   246

                            for varinfo in varinfos])

   247

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

   248

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

   249

                             varpubfmt) % varinfo

   250

                            for varinfo in varinfos])

   251

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

   252

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

   253

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

   254

   255

        loc_dict = {

   256

            "vardec": vardec,

   257

            "varinit": varinit,

   258

            "varret": varret,

   259

            "varpub": varpub,

   260

            "location_str": location_str,

   261

        }

   262

   263

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

   264

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

   265

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

   266

        PyCFileContent = """\

   267

/*

   268

 * Code generated by Beremiz py_ext confnode

   269

 * for safe global variables access

   270

 */

   271

#include "iec_types_all.h"

   272

#include "POUS.h"

   273

#include "config.h"

   274

#include "beremiz.h"

   275

   276

/* User variables reference */

   277

%(vardec)s

   278

   279

/* Beremiz confnode functions */

   280

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

   281

%(varinit)s

   282

    return 0;

   283

}

   284

   285

void __cleanup_%(location_str)s(void){

   286

}

   287

   288

void __retrieve_%(location_str)s(void){

   289

%(varret)s

   290

}

   291

   292

void __publish_%(location_str)s(void){

   293

%(varpub)s

   294

}

   295

""" % loc_dict

   296

   297

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

   298

        pycfile = open(Gen_PyCfile_path, 'w')

   299

        pycfile.write(PyCFileContent)

   300

        pycfile.close()

   301

   302

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

   303

            self.GetCTRoot().GetIECLibPath())

   304

   305

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   306

                "",

   307

                True,

   308

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