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

    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

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

   124

            return [onchangecall.strip() + "('" + var.getname() + "')"

   126

   127

        def _onchange(var):

   130

   131

        pyextname = self.CTNName()

   132

        varinfos = map(

   133

            lambda variable: {

   134

                "name": variable.getname(),

   135

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

   136

                "onchangecode": _onchangecode(variable),

   137

                "onchange": _onchange(variable),

   138

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

   139

                "configname": configname.upper(),

   140

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

   141

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

   142

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

   143

                "pyextname": pyextname

   144

            },

   145

            self.CodeFile.variables.variable)

   146

   147

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

   148

   149

        # python side PLC global variables access stub

   150

        globalstubs = "\n".join([

   151

            """\

   152

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

   153

    TypeTranslator["%(IECtype)s"]

   154

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

   155

_PySafeGetPLCGlob_%(name)s.restype = None

   156

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

   157

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

   158

_PySafeSetPLCGlob_%(name)s.restype = None

   159

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

   160

_%(pyextname)sGlobalsDesc.append((

   161

    "%(name)s",

   162

    "%(IECtype)s",

   163

    %(initial)s,

   164

    %(desc)s,

   165

    %(onchange)s,

   166

    %(opts)s))

   167

""" % varinfo for varinfo in varinfos])

   168

   169

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

   170

    if changes.next():

   171

        # %(name)s

   172

        try:

   173

""" % varinfo + """ 

   174

            """ + """

   175

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

   176

        except Exception as e:

   177

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

   178

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

   179

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

   180

        rtcalls = ""

   181

        for section in self.SECTIONS_NAMES:

   182

            if section != "globals":

   183

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

   184

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

   185

                if sectiontext:

   186

                    rtcalls += '    ' + \

   187

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

   188

                else:

   189

                    rtcalls += "    pass\n\n"

   190

   191

        globalsection = self.GetSection("globals")

   192

   193

        loc_dict = {

   194

            "pyextname": pyextname,

   195

            "globalstubs": globalstubs,

   196

            "globalsection": globalsection,

   197

            "rtcalls": rtcalls,

   198

            "location_str": location_str,

   199

            "on_change_func_body":on_change_func_body,

   200

            "onchange_var_count": onchange_var_count

   201

        }

   202

   203

        PyFileContent = """\

   204

#!/usr/bin/env python

   205

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

   206

## Code generated by Beremiz python mixin confnode

   207

##

   208

   209

## Code for PLC global variable access

   210

from runtime.typemapping import TypeTranslator

   211

import ctypes

   212

   213

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

   214

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

   215

_PySafeGetChanges_%(pyextname)s.argtypes = None

   216

   217

_%(pyextname)sGlobalsDesc = []

   218

__ext_name__ = "%(pyextname)s"

   219

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

   220

%(globalstubs)s

   221

   222

## User code in "global" scope

   223

%(globalsection)s

   224

   225

## Beremiz python runtime calls

   226

%(rtcalls)s

   227

   228

def On_%(pyextname)s_Change():

   229

    changesP = _PySafeGetChanges_%(pyextname)s()

   230

    if not changesP:

   231

        raise Exception("PySafeGetChanges returned NULL!")

   232

    changes = iter(changesP.contents)

   233

    errors = []

   234

%(on_change_func_body)s

   235

    if len(errors)>0 :

   236

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

   237

   238

del __ext_name__

   239

   240

""" % loc_dict

   241

   242

        # write generated content to python file

   243

        runtimefile_path = os.path.join(buildpath,

   244

                                        "runtime_%s.py" % location_str)

   245

        runtimefile = open(runtimefile_path, 'w')

   246

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

   247

        runtimefile.close()

   248

   249

        # C code for safe global variables access

   250

   251

        vardecfmt = """\

   252

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

   253

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

   254

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

   255

long __%(name)s_rlock = 0;

   256

long __%(name)s_wlock = 0;

   257

int __%(name)s_wbuffer_written = 0;

   258

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

   259

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

   260

    *pvalue = __%(name)s_rbuffer;

   261

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

   262

}

   263

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

   264

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

   265

    __%(name)s_wbuffer = *value;

   266

    __%(name)s_wbuffer_written = 1;

   267

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

   268

}

   269

   270

"""

   271

   272

        vardeconchangefmt = """\

   273

int __%(name)s_rbuffer_written = 0;

   274

"""

   275

   276

        varretfmt = """\

   277

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

   278

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

   279

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

   280

            __%(name)s_wbuffer_written = 0;

   281

        }

   282

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

   283

    }

   284

"""

   285

        varpubfmt = """\

   286

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

   287

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

   288

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

   289

    }

   290

"""

   291

   292

        varpubonchangefmt = """\

   293

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

   294

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

   295

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

   296

            __%(name)s_rbuffer = tmp;

   297

            /* mark variable as changed */

   298

            __%(name)s_rbuffer_written = 1;

   299

            some_change = 1;

   300

        }

   301

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

   302

    }

   303

"""

   304

   305

        varcollectchangefmt = """\

   306

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

   307

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

   308

    /* mark variable as unchanged */

   309

    __%(name)s_rbuffer_written = 0;

   310

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

   311

   312

"""

   313

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

   314

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

   315

                            for varinfo in varinfos])

   316

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

   317

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

   318

                             varpubfmt) % varinfo

   319

                            for varinfo in varinfos])

   320

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

   321

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

   322

   323

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

   324

   325

        loc_dict = {

   326

            "vardec": vardec,

   327

            "varret": varret,

   328

            "varpub": varpub,

   329

            "location_str": location_str,

   330

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

   331

            "pysafe_pypoll_code_len": len(pysafe_pypoll_code),

   332

            "varcollectchange": varcollectchange,

   333

            "onchange_var_count": onchange_var_count

   334

        }

   335

   336

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

   337

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

   338

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

   339

        PyCFileContent = """\

   340

/*

   341

 * Code generated by Beremiz py_ext confnode

   342

 * for safe global variables access

   343

 */

   344

#include "iec_types_all.h"

   345

#include "POUS.h"

   346

#include "config.h"

   347

#include "beremiz.h"

   348

   349

PYTHON_POLL* __%(location_str)s_notifier;

   350

   351

/* User variables reference */

   352

%(vardec)s

   353

   354

/* Beremiz confnode functions */

   355

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

   356

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

   357

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

   358

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

   359

   360

    return 0;

   361

}

   362

   363

void __cleanup_%(location_str)s(void){

   364

}

   365

   366

void __retrieve_%(location_str)s(void){

   367

%(varret)s

   368

}

   369

   370

void __publish_%(location_str)s(void){

   371

    int some_change = 0;

   372

%(varpub)s

   373

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

   374

    if(some_change){

   375

        PYTHON_POLL_body__(__%(location_str)s_notifier);

   376

    }

   377

}

   378

   379

static int pysafe_changes[%(onchange_var_count)d];

   380

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

   381

    int change_index=0;

   382

%(varcollectchange)s

   383

    return (void*)&pysafe_changes[0];

   384

}

   385

   386

""" % loc_dict

   387

   388

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

   389

        pycfile = open(Gen_PyCfile_path, 'w')

   390

        pycfile.write(PyCFileContent)

   391

        pycfile.close()

   392

   393

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

   394

            self.GetCTRoot().GetIECLibPath())

   395

   396

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   397

                "",

   398

                True,

   399

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