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(lambda x: str(x),

    99

                                self.GetCurrentLocation()))

   100

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

   101

   102

        pyextname = self.CTNName()

   103

        varinfos = map(lambda variable: {

   104

                    "name": variable.getname(),

   105

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

   106

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

   107

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

   108

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

   109

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

   110

                                 if variable.getonchange() else None,

   111

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

   112

                    "configname": configname.upper(),

   113

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

   114

                    "IECtype": variable.gettype(),

   115

                    "pyextname": pyextname},

   116

                    self.CodeFile.variables.variable)

   117

        # python side PLC global variables access stub

   118

        globalstubs = "\n".join(["""\

   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

   134

      for varinfo in varinfos])

   135

   136

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

   137

        rtcalls = ""

   138

        for section in self.SECTIONS_NAMES:

   139

            if section != "globals":

   140

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

   141

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

   142

                if sectiontext:

   143

                    rtcalls += '    ' + \

   144

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

   145

                else:

   146

                    rtcalls += "    pass\n\n"

   147

   148

        globalsection = self.GetSection("globals")

   149

   150

        PyFileContent = """\

   151

#!/usr/bin/env python

   152

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

   153

## Code generated by Beremiz python mixin confnode

   154

##

   155

   156

## Code for PLC global variable access

   157

from targets.typemapping import TypeTranslator

   158

import ctypes

   159

_%(pyextname)sGlobalsDesc = []

   160

__ext_name__ = "%(pyextname)s"

   161

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

   162

%(globalstubs)s

   163

   164

## User code in "global" scope

   165

%(globalsection)s

   166

   167

## Beremiz python runtime calls

   168

%(rtcalls)s

   169

   170

del __ext_name__

   171

   172

""" % locals()

   173

   174

        # write generated content to python file

   175

        runtimefile_path = os.path.join(buildpath,

   176

            "runtime_%s.py" % location_str)

   177

        runtimefile = open(runtimefile_path, 'w')

   178

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

   179

        runtimefile.close()

   180

   181

        # C code for safe global variables access

   182

   183

        vardecfmt = """\

   184

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

   185

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

   186

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

   187

long __%(name)s_rlock = 0;

   188

long __%(name)s_wlock = 0;

   189

int __%(name)s_wbuffer_written = 0;

   190

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

   191

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

   192

    *pvalue = __%(name)s_rbuffer;

   193

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

   194

}

   195

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

   196

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

   197

    __%(name)s_wbuffer = *value;

   198

    __%(name)s_wbuffer_written = 1;

   199

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

   200

}

   201

   202

"""

   203

   204

        vardeconchangefmt = """\

   205

PYTHON_POLL* __%(name)s_notifier;

   206

"""

   207

   208

        varretfmt = """\

   209

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

   210

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

   211

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

   212

            __%(name)s_wbuffer_written = 0;

   213

        }

   214

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

   215

    }

   216

"""

   217

        varpubfmt = """\

   218

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

   219

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

   220

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

   221

    }

   222

"""

   223

   224

        varpubonchangefmt = """\

   225

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

   226

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

   227

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

   228

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

   229

            PYTHON_POLL_body__(__%(name)s_notifier);

   230

        }

   231

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

   232

    }

   233

"""

   234

        varinitonchangefmt = """\

   235

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

   236

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

   237

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

   238

"""

   239

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

   240

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

   241

                            for varinfo in varinfos])

   242

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

   243

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

   244

                             varpubfmt) % varinfo

   245

                            for varinfo in varinfos])

   246

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

   247

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

   248

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

   249

   250

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

   251

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

   252

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

   253

        PyCFileContent = """\

   254

/*

   255

 * Code generated by Beremiz py_ext confnode

   256

 * for safe global variables access

   257

 */

   258

#include "iec_types_all.h"

   259

#include "POUS.h"

   260

#include "config.h"

   261

#include "beremiz.h"

   262

   263

/* User variables reference */

   264

%(vardec)s

   265

   266

/* Beremiz confnode functions */

   267

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

   268

%(varinit)s

   269

    return 0;

   270

}

   271

   272

void __cleanup_%(location_str)s(void){

   273

}

   274

   275

void __retrieve_%(location_str)s(void){

   276

%(varret)s

   277

}

   278

   279

void __publish_%(location_str)s(void){

   280

%(varpub)s

   281

}

   282

""" % locals()

   283

   284

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

   285

        pycfile = open(Gen_PyCfile_path, 'w')

   286

        pycfile.write(PyCFileContent)

   287

        pycfile.close()

   288

   289

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

   290

            self.GetCTRoot().GetIECLibPath())

   291

   292

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   293

                "",

   294

                True,

   295

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