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

    40

    41

class PythonFileCTNMixin(CodeFile):

    42

    43

    CODEFILE_NAME = "PyFile"

    44

    SECTIONS_NAMES = [

    45

        "globals",

    46

        "init",

    47

        "cleanup",

    48

        "start",

    49

        "stop"]

    50

    EditorType = PythonEditor

    51

    52

    def __init__(self):

    53

        CodeFile.__init__(self)

    54

    55

        filepath = self.PythonFileName()

    56

    57

        if os.path.isfile(filepath):

    58

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

    59

    60

            xmlfile = open(filepath, 'r')

    61

            pythonfile_xml = xmlfile.read()

    62

            xmlfile.close()

    63

    64

            pythonfile_xml = pythonfile_xml.replace(

    65

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

    66

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

    67

            for cre, repl in [

    68

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

    69

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

    70

                pythonfile_xml = cre.sub(repl, pythonfile_xml)

    71

    72

            try:

    73

                python_code, error = PythonParser.LoadXMLString(pythonfile_xml)

    74

                if error is None:

    75

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

    76

                    os.remove(filepath)

    77

                    self.CreateCodeFileBuffer(False)

    78

                    self.OnCTNSave()

    79

            except Exception as exc:

    80

                error = text(exc)

    81

    82

            if error is not None:

    83

                self.GetCTRoot().logger.write_error(

    84

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

    85

    86

    def CodeFileName(self):

    87

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

    88

    89

    def PythonFileName(self):

    90

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

    91

    92

    PreSectionsTexts = {}

    93

    PostSectionsTexts = {}

    94

    95

    def GetSection(self, section):

    96

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

    97

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

    98

               self.PostSectionsTexts.get(section, "")

    99

   100

    def CTNGlobalInstances(self):

   101

        variables = self.CodeFileVariables(self.CodeFile)

   102

        ret = [(variable.getname(),

   103

                variable.gettype(),

   104

                variable.getinitial())

   105

               for variable in variables]

   106

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

   107

        ret.append(("On_"+location_str+"_Change", "python_poll", ""))

   108

        return ret

   109

   110

    @staticmethod

   111

    def GetVarOnChangeContent(var):

   112

        """

   113

        returns given variable onchange field

   114

        function is meant to allow customization 

   115

        """

   116

        return var.getonchange()

   117

   118

    def CTNGenerate_C(self, buildpath, locations):

   119

        # location string for that CTN

   120

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

   121

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

   122

   123

        def _onchangecode(var):

   131

   132

        def _onchange(var):

   133

            content = self.GetVarOnChangeContent(var)

   134

            return repr(content) if content else None

   135

   136

        pyextname = self.CTNName()

   137

        varinfos = map(

   138

            lambda variable: {

   139

                "name": variable.getname(),

   140

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

   141

                "onchangecode": _onchangecode(variable),

   142

                "onchange": _onchange(variable),

   143

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

   144

                "configname": configname.upper(),

   145

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

   146

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

   147

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

   148

                "pyextname": pyextname

   149

            },

   150

            self.CodeFile.variables.variable)

   151

   152

        onchange_var_count = len([None for varinfo in varinfos if varinfo["onchange"]])

   153

   154

        # python side PLC global variables access stub

   155

        globalstubs = "\n".join([

   156

            """\

   157

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

   158

    TypeTranslator["%(IECtype)s"]

   159

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

   160

_PySafeGetPLCGlob_%(name)s.restype = None

   161

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

   162

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

   163

_PySafeSetPLCGlob_%(name)s.restype = None

   164

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

   165

_%(pyextname)sGlobalsDesc.append((

   166

    "%(name)s",

   167

    "%(IECtype)s",

   168

    %(initial)s,

   169

    %(desc)s,

   170

    %(onchange)s,

   171

    %(opts)s))

   172

""" % varinfo for varinfo in varinfos])

   173

   174

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

   175

    if changes.next():

   176

        # %(name)s

   178

            """ + """

   179

            """.join(varinfo['onchangecode'])+"""

   180

        except Exception as e:

   181

            errors.append("%(name)s: "+str(e))

   182

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

   183

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

   184

        rtcalls = ""

   185

        for section in self.SECTIONS_NAMES:

   186

            if section != "globals":

   187

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

   188

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

   189

                if sectiontext:

   190

                    rtcalls += '    ' + \

   191

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

   192

                else:

   193

                    rtcalls += "    pass\n\n"

   194

   195

        globalsection = self.GetSection("globals")

   196

   197

        loc_dict = {

   198

            "pyextname": pyextname,

   199

            "globalstubs": globalstubs,

   200

            "globalsection": globalsection,

   201

            "rtcalls": rtcalls,

   202

            "location_str": location_str,

   203

            "on_change_func_body":on_change_func_body,

   204

            "onchange_var_count": onchange_var_count

   205

        }

   206

   207

        PyFileContent = """\

   208

#!/usr/bin/env python

   209

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

   210

## Code generated by Beremiz python mixin confnode

   211

##

   212

   213

## Code for PLC global variable access

   214

from runtime.typemapping import TypeTranslator

   215

import ctypes

   216

   217

_PySafeGetChanges_%(pyextname)s = PLCBinary.PySafeGetChanges_%(location_str)s

   218

_PySafeGetChanges_%(pyextname)s.restype = ctypes.POINTER(ctypes.c_int * %(onchange_var_count)d)

   219

_PySafeGetChanges_%(pyextname)s.argtypes = None

   220

   221

_%(pyextname)sGlobalsDesc = []

   222

__ext_name__ = "%(pyextname)s"

   223

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

   224

%(globalstubs)s

   225

   226

## User code in "global" scope

   227

%(globalsection)s

   228

   229

## Beremiz python runtime calls

   230

%(rtcalls)s

   231

   232

def On_%(pyextname)s_Change():

   233

    changesP = _PySafeGetChanges_%(pyextname)s()

   234

    if not changesP:

   235

        raise Exception("PySafeGetChanges returned NULL!")

   236

    changes = iter(changesP.contents)

   237

    errors = []

   238

%(on_change_func_body)s

   239

    if len(errors)>0 :

   240

        raise Exception("Exception in %(pyextname)s OnChange call:\\\\n" + "\\\\n".join(errors))

   241

   242

del __ext_name__

   243

   244

""" % loc_dict

   245

   246

        # write generated content to python file

   247

        runtimefile_path = os.path.join(buildpath,

   248

                                        "runtime_%s.py" % location_str)

   249

        runtimefile = open(runtimefile_path, 'w')

   250

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

   251

        runtimefile.close()

   252

   253

        # C code for safe global variables access

   254

   255

        vardecfmt = """\

   256

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

   257

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

   258

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

   259

long __%(name)s_rlock = 0;

   260

long __%(name)s_wlock = 0;

   261

int __%(name)s_wbuffer_written = 0;

   262

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

   263

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

   264

    *pvalue = __%(name)s_rbuffer;

   265

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

   266

}

   267

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

   268

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

   269

    __%(name)s_wbuffer = *value;

   270

    __%(name)s_wbuffer_written = 1;

   271

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

   272

}

   273

   274

"""

   275

   276

        vardeconchangefmt = """\

   277

int __%(name)s_rbuffer_written = 0;

   278

"""

   279

   280

        varretfmt = """\

   281

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

   282

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

   283

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

   284

            __%(name)s_wbuffer_written = 0;

   285

        }

   286

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

   287

    }

   288

"""

   289

        varpubfmt = """\

   290

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

   291

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

   292

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

   293

    }

   294

"""

   295

   296

        varpubonchangefmt = """\

   297

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

   298

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

   299

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

   300

            __%(name)s_rbuffer = tmp;

   301

            /* mark variable as changed */

   302

            __%(name)s_rbuffer_written = 1;

   303

            some_change = 1;

   304

        }

   305

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

   306

    }

   307

"""

   308

   309

        varcollectchangefmt = """\

   310

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

   311

    pysafe_changes[change_index++] = __%(name)s_rbuffer_written;

   312

    /* mark variable as unchanged */

   313

    __%(name)s_rbuffer_written = 0;

   314

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

   315

   316

"""

   317

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

   318

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

   319

                            for varinfo in varinfos])

   320

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

   321

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

   322

                             varpubfmt) % varinfo

   323

                            for varinfo in varinfos])

   324

        varcollectchange = "\n".join([varcollectchangefmt % varinfo

   325

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

   326

   327

        pysafe_pypoll_code = "On_"+pyextname+"_Change()"

   328

   329

        loc_dict = {

   330

            "vardec": vardec,

   331

            "varret": varret,

   332

            "varpub": varpub,

   333

            "location_str": location_str,

   334

            "pysafe_pypoll_code": '"'+pysafe_pypoll_code+'"',

   335

            "pysafe_pypoll_code_len": len(pysafe_pypoll_code),

   336

            "varcollectchange": varcollectchange,

   337

            "onchange_var_count": onchange_var_count

   338

        }

   339

   340

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

   341

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

   342

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

   343

        PyCFileContent = """\

   344

/*

   345

 * Code generated by Beremiz py_ext confnode

   346

 * for safe global variables access

   347

 */

   348

#include "iec_types_all.h"

   349

#include "POUS.h"

   350

#include "config.h"

   351

#include "beremiz.h"

   352

   353

PYTHON_POLL* __%(location_str)s_notifier;

   354

   355

/* User variables reference */

   356

%(vardec)s

   357

   358

/* Beremiz confnode functions */

   359

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

   360

    __%(location_str)s_notifier = __GET_GLOBAL_ON_%(location_str)s_CHANGE();

   361

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

   362

    __SET_VAR(__%(location_str)s_notifier->,CODE,,__STRING_LITERAL(%(pysafe_pypoll_code_len)d,%(pysafe_pypoll_code)s));

   363

   364

    return 0;

   365

}

   366

   367

void __cleanup_%(location_str)s(void){

   368

}

   369

   370

void __retrieve_%(location_str)s(void){

   371

%(varret)s

   372

}

   373

   374

void __publish_%(location_str)s(void){

   375

    int some_change = 0;

   376

%(varpub)s

   377

    // call python part if there was at least a change

   378

    if(some_change){

   379

        PYTHON_POLL_body__(__%(location_str)s_notifier);

   380

    }

   381

}

   382

   383

static int pysafe_changes[%(onchange_var_count)d];

   384

void* PySafeGetChanges_%(location_str)s(void){

   385

    int change_index=0;

   386

%(varcollectchange)s

   387

    return (void*)&pysafe_changes[0];

   388

}

   389

   390

""" % loc_dict

   391

   392

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

   393

        pycfile = open(Gen_PyCfile_path, 'w')

   394

        pycfile.write(PyCFileContent)

   395

        pycfile.close()

   396

   397

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

   398

            self.GetCTRoot().GetIECLibPath())

   399

   400

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   401

                "",

   402

                True,

   403

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