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

   124

            result = []

   125

            for onchangecall in self.GetVarOnChangeContent(var).split(','):

   126

                onchangecall = onchangecall.strip()

   127

                if onchangecall:

   128

                    result.append(onchangecall + "('" + var.getname() + "')")

   129

            return result

   130

   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 + ("""

   173

_PyOnChangeCount_%(name)s = ctypes.c_uint.in_dll(PLCBinary,"__%(name)s_onchange_count")

   174

_PyOnChangeFirst_%(name)s = _%(name)s_ctype.in_dll(PLCBinary,"__%(name)s_onchange_firstval")

   175

_PyOnChangeLast_%(name)s = _%(name)s_ctype.in_dll(PLCBinary,"__%(name)s_onchange_lastval")

   176

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

   177

   178

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

   179

    if _PyOnChangeCount_%(name)s.value > 0:

   180

        # %(name)s

   181

        try:""" % varinfo + """

   182

            """ + """

   183

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

   184

        except Exception as e:

   185

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

   186

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

   187

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

   188

        rtcalls = ""

   189

        for section in self.SECTIONS_NAMES:

   190

            if section != "globals":

   191

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

   192

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

   193

                if sectiontext:

   194

                    rtcalls += '    ' + \

   195

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

   196

                else:

   197

                    rtcalls += "    pass\n\n"

   198

   199

        globalsection = self.GetSection("globals")

   200

   201

        loc_dict = {

   202

            "pyextname": pyextname,

   203

            "globalstubs": globalstubs,

   204

            "globalsection": globalsection,

   205

            "rtcalls": rtcalls,

   206

            "location_str": location_str,

   207

            "on_change_func_body":on_change_func_body,

   208

            "onchange_var_count": onchange_var_count

   209

        }

   210

   211

        PyFileContent = """\

   212

#!/usr/bin/env python

   213

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

   214

## Code generated by Beremiz python mixin confnode

   215

##

   216

   217

## Code for PLC global variable access

   218

from runtime.typemapping import TypeTranslator

   219

import ctypes

   220

   221

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

   222

_PySafeGetChanges_%(pyextname)s.restype = None

   223

_PySafeGetChanges_%(pyextname)s.argtypes = None

   224

   225

_%(pyextname)sGlobalsDesc = []

   226

__ext_name__ = "%(pyextname)s"

   227

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

   228

%(globalstubs)s

   229

   230

## User code in "global" scope

   231

%(globalsection)s

   232

   233

## Beremiz python runtime calls

   234

%(rtcalls)s

   235

   236

def On_%(pyextname)s_Change():

   237

    _PySafeGetChanges_%(pyextname)s()

   238

    errors = []

   239

%(on_change_func_body)s

   240

    if len(errors)>0 :

   241

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

   242

   243

del __ext_name__

   244

   245

""" % loc_dict

   246

   247

        # write generated content to python file

   248

        runtimefile_path = os.path.join(buildpath,

   249

                                        "runtime_%s.py" % location_str)

   250

        runtimefile = open(runtimefile_path, 'w')

   251

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

   252

        runtimefile.close()

   253

   254

        # C code for safe global variables access

   255

   256

        vardecfmt = """\

   257

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

   258

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

   259

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

   260

long __%(name)s_rlock = 0;

   261

long __%(name)s_wlock = 0;

   262

int __%(name)s_wbuffer_written = 0;

   263

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

   264

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

   265

    *pvalue = __%(name)s_rbuffer;

   266

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

   267

}

   268

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

   269

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

   270

    __%(name)s_wbuffer = *value;

   271

    __%(name)s_wbuffer_written = 1;

   272

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

   273

}

   274

   275

"""

   276

   277

        vardeconchangefmt = """\

   278

unsigned int __%(name)s_rbuffer_written = 0;

   279

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

   280

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

   281

unsigned int __%(name)s_onchange_count = 0;

   282

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

   283

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

   284

"""

   285

   286

        varretfmt = """\

   287

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

   288

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

   289

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

   290

            __%(name)s_wbuffer_written = 0;

   291

        }

   292

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

   293

    }

   294

"""

   295

        varpubfmt = """\

   296

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

   297

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

   298

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

   299

    }

   300

"""

   301

   302

        varpubonchangefmt = """\

   303

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

   304

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

   305

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

   306

            if(__%(name)s_rbuffer_written == 0);

   307

                __%(name)s_rbuffer_firstval = __%(name)s_rbuffer;

   308

            __%(name)s_rbuffer_lastval = tmp;

   309

            __%(name)s_rbuffer = tmp;

   310

            /* count one more change */

   311

            __%(name)s_rbuffer_written += 1;

   312

            some_change_found = 1;

   313

        }

   314

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

   315

    }

   316

"""

   317

   318

        varcollectchangefmt = """\

   319

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

   320

    __%(name)s_onchange_count = __%(name)s_rbuffer_written;

   321

    __%(name)s_onchange_firstval = __%(name)s_rbuffer_firstval;

   322

    __%(name)s_onchange_lastval = __%(name)s_rbuffer_lastval;

   323

    /* mark variable as unchanged */

   324

    __%(name)s_rbuffer_written = 0;

   325

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

   326

   327

"""

   328

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

   329

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

   330

                            for varinfo in varinfos])

   331

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

   332

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

   333

                             varpubfmt) % varinfo

   334

                            for varinfo in varinfos])

   335

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

   336

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

   337

   338

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

   339

   340

        loc_dict = {

   341

            "vardec": vardec,

   342

            "varret": varret,

   343

            "varpub": varpub,

   344

            "location_str": location_str,

   345

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

   346

            "pysafe_pypoll_code_len": len(pysafe_pypoll_code),

   347

            "varcollectchange": varcollectchange,

   348

            "onchange_var_count": onchange_var_count

   349

        }

   350

   351

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

   352

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

   353

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

   354

        PyCFileContent = """\

   355

/*

   356

 * Code generated by Beremiz py_ext confnode

   357

 * for safe global variables access

   358

 */

   359

#include "iec_types_all.h"

   360

#include "POUS.h"

   361

#include "config.h"

   362

#include "beremiz.h"

   363

   364

PYTHON_POLL* __%(location_str)s_notifier;

   365

   366

/* User variables reference */

   367

%(vardec)s

   368

   369

/* Beremiz confnode functions */

   370

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

   371

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

   372

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

   373

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

   374

   375

    return 0;

   376

}

   377

   378

void __cleanup_%(location_str)s(void){

   379

}

   380

   381

void __retrieve_%(location_str)s(void){

   382

%(varret)s

   383

}

   384

   385

static int passing_changes_to_python = 0;

   386

void __publish_%(location_str)s(void){

   387

    int some_change_found = 0;

   388

%(varpub)s

   389

    passing_changes_to_python |= some_change_found;

   390

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

   391

    if(passing_changes_to_python){

   392

        PYTHON_POLL_body__(__%(location_str)s_notifier);

   393

        passing_changes_to_python &= !(__GET_VAR(__%(location_str)s_notifier->ACK,));

   394

    }

   395

}

   396

   397

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

   398

%(varcollectchange)s

   399

}

   400

   401

""" % loc_dict

   402

   403

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

   404

        pycfile = open(Gen_PyCfile_path, 'w')

   405

        pycfile.write(PyCFileContent)

   406

        pycfile.close()

   407

   408

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

   409

            self.GetCTRoot().GetIECLibPath())

   410

   411

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   412

                "",

   413

                True,

   414

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