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

from lxml import etree

    29

import util.paths as paths

    30

    31

from xmlclass import GenerateParserFromXSD

    32

    33

from CodeFileTreeNode import CodeFile

    34

from PythonEditor import PythonEditor

    35

    36

    37

class PythonFileCTNMixin(CodeFile):

    38

    39

    CODEFILE_NAME = "PyFile"

    40

    SECTIONS_NAMES = [

    41

        "globals",

    42

        "init",

    43

        "cleanup",

    44

        "start",

    45

        "stop"]

    46

    EditorType = PythonEditor

    47

    48

    def __init__(self):

    49

        CodeFile.__init__(self)

    50

    51

        filepath = self.PythonFileName()

    52

    53

        if os.path.isfile(filepath):

    54

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

    55

    56

            xmlfile = open(filepath, 'r')

    57

            pythonfile_xml = xmlfile.read()

    58

            xmlfile.close()

    59

    60

            pythonfile_xml = pythonfile_xml.replace(

    61

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

    62

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

    63

            for cre, repl in [

    64

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

    65

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

    66

                pythonfile_xml = cre.sub(repl, pythonfile_xml)

    67

    68

            try:

    69

                python_code, error = PythonParser.LoadXMLString(pythonfile_xml)

    70

                if error is None:

    71

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

    72

                    os.remove(filepath)

    73

                    self.CreateCodeFileBuffer(False)

    74

                    self.OnCTNSave()

    75

            except Exception, exc:

    76

                error = unicode(exc)

    77

    78

            if error is not None:

    79

                self.GetCTRoot().logger.write_error(

    80

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

    81

    82

    def CodeFileName(self):

    83

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

    84

    85

    def PythonFileName(self):

    86

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

    87

    88

    PreSectionsTexts = {}

    89

    PostSectionsTexts = {}

    90

    91

    def GetSection(self, section):

    92

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

    93

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

    94

               self.PostSectionsTexts.get(section, "")

    95

    96

    def CTNGenerate_C(self, buildpath, locations):

    97

        # location string for that CTN

    98

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

    99

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

   100

   101

        pyextname = self.CTNName()

   102

        varinfos = map(lambda variable: {

   103

            "name": variable.getname(),

   104

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

   105

            "onchangecode": '"' + variable.getonchange() +

   106

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

   107

            if variable.getonchange() else '""',

   108

            "onchange": repr(variable.getonchange())

   109

            if variable.getonchange() else None,

   110

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

   111

            "configname": configname.upper(),

   112

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

   113

            "IECtype": variable.gettype(),

   114

            "pyextname": pyextname},

   115

                       self.CodeFile.variables.variable)

   116

        # python side PLC global variables access stub

   117

        globalstubs = "\n".join([

   118

            """\

   119

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

   120

    TypeTranslator["%(IECtype)s"]

   121

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

   122

_PySafeGetPLCGlob_%(name)s.restype = None

   123

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

   124

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

   125

_PySafeSetPLCGlob_%(name)s.restype = None

   126

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

   127

_%(pyextname)sGlobalsDesc.append((

   128

    "%(name)s",

   129

    "%(IECtype)s",

   130

    %(desc)s,

   131

    %(onchange)s,

   132

    %(opts)s))

   133

""" % varinfo for varinfo in varinfos])

   134

   135

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

   136

        rtcalls = ""

   137

        for section in self.SECTIONS_NAMES:

   138

            if section != "globals":

   139

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

   140

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

   141

                if sectiontext:

   142

                    rtcalls += '    ' + \

   143

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

   144

                else:

   145

                    rtcalls += "    pass\n\n"

   146

   147

        globalsection = self.GetSection("globals")

   148

   149

        PyFileContent = """\

   150

#!/usr/bin/env python

   151

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

   152

## Code generated by Beremiz python mixin confnode

   153

##

   154

   155

## Code for PLC global variable access

   156

from targets.typemapping import TypeTranslator

   157

import ctypes

   158

_%(pyextname)sGlobalsDesc = []

   159

__ext_name__ = "%(pyextname)s"

   160

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

   161

%(globalstubs)s

   162

   163

## User code in "global" scope

   164

%(globalsection)s

   165

   166

## Beremiz python runtime calls

   167

%(rtcalls)s

   168

   169

del __ext_name__

   170

   171

""" % locals()

   172

   173

        # write generated content to python file

   174

        runtimefile_path = os.path.join(buildpath,

   175

                                        "runtime_%s.py" % location_str)

   176

        runtimefile = open(runtimefile_path, 'w')

   177

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

   178

        runtimefile.close()

   179

   180

        # C code for safe global variables access

   181

   182

        vardecfmt = """\

   183

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

   184

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

   185

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

   186

long __%(name)s_rlock = 0;

   187

long __%(name)s_wlock = 0;

   188

int __%(name)s_wbuffer_written = 0;

   189

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

   190

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

   191

    *pvalue = __%(name)s_rbuffer;

   192

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

   193

}

   194

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

   195

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

   196

    __%(name)s_wbuffer = *value;

   197

    __%(name)s_wbuffer_written = 1;

   198

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

   199

}

   200

   201

"""

   202

   203

        vardeconchangefmt = """\

   204

PYTHON_POLL* __%(name)s_notifier;

   205

"""

   206

   207

        varretfmt = """\

   208

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

   209

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

   210

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

   211

            __%(name)s_wbuffer_written = 0;

   212

        }

   213

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

   214

    }

   215

"""

   216

        varpubfmt = """\

   217

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

   218

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

   219

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

   220

    }

   221

"""

   222

   223

        varpubonchangefmt = """\

   224

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

   225

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

   226

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

   227

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

   228

            PYTHON_POLL_body__(__%(name)s_notifier);

   229

        }

   230

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

   231

    }

   232

"""

   233

        varinitonchangefmt = """\

   234

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

   235

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

   236

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

   237

"""

   238

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

   239

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

   240

                            for varinfo in varinfos])

   241

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

   242

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

   243

                             varpubfmt) % varinfo

   244

                            for varinfo in varinfos])

   245

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

   246

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

   247

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

   248

   249

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

   250

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

   251

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

   252

        PyCFileContent = """\

   253

/*

   254

 * Code generated by Beremiz py_ext confnode

   255

 * for safe global variables access

   256

 */

   257

#include "iec_types_all.h"

   258

#include "POUS.h"

   259

#include "config.h"

   260

#include "beremiz.h"

   261

   262

/* User variables reference */

   263

%(vardec)s

   264

   265

/* Beremiz confnode functions */

   266

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

   267

%(varinit)s

   268

    return 0;

   269

}

   270

   271

void __cleanup_%(location_str)s(void){

   272

}

   273

   274

void __retrieve_%(location_str)s(void){

   275

%(varret)s

   276

}

   277

   278

void __publish_%(location_str)s(void){

   279

%(varpub)s

   280

}

   281

""" % locals()

   282

   283

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

   284

        pycfile = open(Gen_PyCfile_path, 'w')

   285

        pycfile.write(PyCFileContent)

   286

        pycfile.close()

   287

   288

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

   289

            self.GetCTRoot().GetIECLibPath())

   290

   291

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   292

                "",

   293

                True,

   294

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