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

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

   138

                "name": variable.getname(),

   139

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

   140

                "onchangecode": _onchangecode(variable),

   141

                "onchange": _onchange(variable),

   142

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

   143

                "configname": configname.upper(),

   144

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

   145

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

   146

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

   147

                "pyextname": pyextname

   149

   150

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

   151

   152

        # python side PLC global variables access stub

   153

        globalstubs = "\n".join([

   154

            """\

   155

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

   156

    TypeTranslator["%(IECtype)s"]

   157

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

   158

_PySafeGetPLCGlob_%(name)s.restype = None

   159

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

   160

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

   161

_PySafeSetPLCGlob_%(name)s.restype = None

   162

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

   163

_%(pyextname)sGlobalsDesc.append((

   164

    "%(name)s",

   165

    "%(IECtype)s",

   166

    %(initial)s,

   167

    %(desc)s,

   168

    %(onchange)s,

   169

    %(opts)s))

   170

""" % varinfo + ("""

   171

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

   172

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

   173

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

   174

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

   175

   176

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

   177

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

   178

        # %(name)s

   179

        try:""" % varinfo + """

   180

            """ + """

   181

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

   182

        except Exception as e:

   183

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

   184

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

   185

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

   186

        rtcalls = ""

   187

        for section in self.SECTIONS_NAMES:

   188

            if section != "globals":

   189

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

   190

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

   191

                if sectiontext:

   192

                    rtcalls += '    ' + \

   193

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

   194

                else:

   195

                    rtcalls += "    pass\n\n"

   196

   197

        globalsection = self.GetSection("globals")

   198

   199

        loc_dict = {

   200

            "pyextname": pyextname,

   201

            "globalstubs": globalstubs,

   202

            "globalsection": globalsection,

   203

            "rtcalls": rtcalls,

   204

            "location_str": location_str,

   205

            "on_change_func_body":on_change_func_body,

   206

            "onchange_var_count": onchange_var_count

   207

        }

   208

   209

        PyFileContent = """\

   210

#!/usr/bin/env python

   211

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

   212

## Code generated by Beremiz python mixin confnode

   213

##

   214

   215

## Code for PLC global variable access

   216

from runtime.typemapping import TypeTranslator

   217

import ctypes

   218

   219

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

   220

_PySafeGetChanges_%(pyextname)s.restype = None

   221

_PySafeGetChanges_%(pyextname)s.argtypes = None

   222

   223

_%(pyextname)sGlobalsDesc = []

   224

__ext_name__ = "%(pyextname)s"

   225

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

   226

%(globalstubs)s

   227

   228

## User code in "global" scope

   229

%(globalsection)s

   230

   231

## Beremiz python runtime calls

   232

%(rtcalls)s

   233

   234

def On_%(pyextname)s_Change():

   235

    _PySafeGetChanges_%(pyextname)s()

   236

    errors = []

   237

%(on_change_func_body)s

   238

    if len(errors)>0 :

   239

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

   240

   241

del __ext_name__

   242

   243

""" % loc_dict

   244

   245

        # write generated content to python file

   246

        runtimefile_path = os.path.join(buildpath,

   247

                                        "runtime_%s.py" % location_str)

   248

        runtimefile = open(runtimefile_path, 'w')

   249

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

   250

        runtimefile.close()

   251

   252

        # C code for safe global variables access

   253

   254

        vardecfmt = """\

   255

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

   256

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

   257

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

   258

long __%(name)s_rlock = 0;

   259

long __%(name)s_wlock = 0;

   260

int __%(name)s_wbuffer_written = 0;

   261

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

   262

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

   263

    *pvalue = __%(name)s_rbuffer;

   264

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

   265

}

   266

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

   267

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

   268

    __%(name)s_wbuffer = *value;

   269

    __%(name)s_wbuffer_written = 1;

   270

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

   271

}

   272

   273

"""

   274

   275

        vardeconchangefmt = """\

   276

unsigned int __%(name)s_rbuffer_written = 0;

   277

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

   278

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

   279

unsigned int __%(name)s_onchange_count = 0;

   280

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

   281

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

   282

"""

   283

   284

        varretfmt = """\

   285

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

   286

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

   287

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

   288

            __%(name)s_wbuffer_written = 0;

   289

        }

   290

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

   291

    }

   292

"""

   293

        varpubfmt = """\

   294

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

   295

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

   296

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

   297

    }

   298

"""

   299

   300

        varpubonchangefmt = """\

   301

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

   302

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

   303

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

   304

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

   305

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

   306

            __%(name)s_rbuffer_lastval = tmp;

   307

            __%(name)s_rbuffer = tmp;

   308

            /* count one more change */

   309

            __%(name)s_rbuffer_written += 1;

   310

            some_change_found = 1;

   311

        }

   312

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

   313

    }

   314

"""

   315

   316

        varcollectchangefmt = """\

   317

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

   318

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

   319

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

   320

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

   321

    /* mark variable as unchanged */

   322

    __%(name)s_rbuffer_written = 0;

   323

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

   324

   325

"""

   326

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

   327

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

   328

                            for varinfo in varinfos])

   329

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

   330

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

   331

                             varpubfmt) % varinfo

   332

                            for varinfo in varinfos])

   333

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

   334

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

   335

   336

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

   337

   338

        loc_dict = {

   339

            "vardec": vardec,

   340

            "varret": varret,

   341

            "varpub": varpub,

   342

            "location_str": location_str,

   343

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

   344

            "pysafe_pypoll_code_len": len(pysafe_pypoll_code),

   345

            "varcollectchange": varcollectchange,

   346

            "onchange_var_count": onchange_var_count

   347

        }

   348

   349

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

   350

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

   351

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

   352

        PyCFileContent = """\

   353

/*

   354

 * Code generated by Beremiz py_ext confnode

   355

 * for safe global variables access

   356

 */

   357

#include "iec_types_all.h"

   358

#include "POUS.h"

   359

#include "config.h"

   360

#include "beremiz.h"

   361

   362

PYTHON_POLL* __%(location_str)s_notifier;

   363

   364

/* User variables reference */

   365

%(vardec)s

   366

   367

/* Beremiz confnode functions */

   368

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

   369

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

   370

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

   371

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

   372

   373

    return 0;

   374

}

   375

   376

void __cleanup_%(location_str)s(void){

   377

}

   378

   379

void __retrieve_%(location_str)s(void){

   380

%(varret)s

   381

}

   382

   383

static int passing_changes_to_python = 0;

   384

void __publish_%(location_str)s(void){

   385

    int some_change_found = 0;

   386

%(varpub)s

   387

    passing_changes_to_python |= some_change_found;

   388

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

   389

    if(passing_changes_to_python){

   390

        PYTHON_POLL_body__(__%(location_str)s_notifier);

   391

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

   392

    }

   393

}

   394

   395

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

   396

%(varcollectchange)s

   397

}

   398

   399

""" % loc_dict

   400

   401

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

   402

        pycfile = open(Gen_PyCfile_path, 'w')

   403

        pycfile.write(PyCFileContent)

   404

        pycfile.close()

   405

   406

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

   407

            self.GetCTRoot().GetIECLibPath())

   408

   409

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   410

                "",

   411

                True,

   412

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