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

import os

    28

import re

    29

    30

import util.paths as paths

    31

from xmlclass import GenerateParserFromXSD

    32

    33

from CodeFileTreeNode import CodeFile

    34

from py_ext.PythonEditor import PythonEditor

    35

    36

    37

    38

    39

class PythonFileCTNMixin(CodeFile):

    40

    41

    CODEFILE_NAME = "PyFile"

    42

    SECTIONS_NAMES = [

    43

        "globals",

    44

        "init",

    45

        "cleanup",

    46

        "start",

    47

        "stop"]

    48

    EditorType = PythonEditor

    49

    50

    def __init__(self):

    51

        CodeFile.__init__(self)

    52

    53

        filepath = self.PythonFileName()

    54

    55

        if os.path.isfile(filepath):

    56

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

    57

    58

            xmlfile = open(filepath, 'r')

    59

            pythonfile_xml = xmlfile.read()

    60

            xmlfile.close()

    61

    62

            pythonfile_xml = pythonfile_xml.replace(

    63

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

    64

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

    65

            for cre, repl in [

    66

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

    67

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

    68

                pythonfile_xml = cre.sub(repl, pythonfile_xml)

    69

    70

            try:

    71

                python_code, error = PythonParser.LoadXMLString(pythonfile_xml)

    72

                if error is None:

    73

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

    74

                    os.remove(filepath)

    75

                    self.CreateCodeFileBuffer(False)

    76

                    self.OnCTNSave()

    77

            except Exception as exc:

    78

                error = str(exc)

    79

    80

            if error is not None:

    81

                self.GetCTRoot().logger.write_error(

    82

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

    83

    84

    def CodeFileName(self):

    85

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

    86

    87

    def PythonFileName(self):

    88

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

    89

    90

    PreSectionsTexts = {}

    91

    PostSectionsTexts = {}

    92

    93

    def GetSection(self, section):

    94

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

    95

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

    96

               self.PostSectionsTexts.get(section, "")

    97

    98

    def CTNGlobalInstances(self):

    99

        variables = self.CodeFileVariables(self.CodeFile)

   100

        ret = [(variable.getname(),

   101

                variable.gettype(),

   102

                variable.getinitial())

   103

               for variable in variables]

   104

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

   105

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

   106

        return ret

   107

   108

    @staticmethod

   109

    def GetVarOnChangeContent(var):

   110

        """

   111

        returns given variable onchange field

   112

        function is meant to allow customization 

   113

        """

   114

        return var.getonchange()

   115

   116

    def CTNGenerate_C(self, buildpath, locations):

   117

        # location string for that CTN

   118

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

   119

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

   120

   121

        def _onchangecode(var):

   122

            result = []

   123

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

   124

                onchangecall = onchangecall.strip()

   125

                if onchangecall:

   126

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

   127

            return result

   128

   129

   130

        def _onchange(var):

   131

            content = self.GetVarOnChangeContent(var)

   132

            return repr(content) if content else None

   133

   134

        pyextname = self.CTNName()

   135

        varinfos = [{

   136

                "name": variable.getname(),

   137

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

   138

                "onchangecode": _onchangecode(variable),

   139

                "onchange": _onchange(variable),

   140

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

   141

                "configname": configname.upper(),

   142

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

   143

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

   144

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

   145

                "pyextname": pyextname

   146

            } for variable in self.CodeFile.variables.variable]

   147

   148

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

   149

   150

        # python side PLC global variables access stub

   151

        globalstubs = "\n".join([

   152

            """\

   153

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

   154

    TypeTranslator["%(IECtype)s"]

   155

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

   156

_PySafeGetPLCGlob_%(name)s.restype = None

   157

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

   158

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

   159

_PySafeSetPLCGlob_%(name)s.restype = None

   160

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

   161

_%(pyextname)sGlobalsDesc.append((

   162

    "%(name)s",

   163

    "%(IECtype)s",

   164

    %(initial)s,

   165

    %(desc)s,

   166

    %(onchange)s,

   167

    %(opts)s))

   168

""" % varinfo + ("""

   169

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

   170

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

   171

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

   172

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

   173

   174

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

   175

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

   176

        # %(name)s

   177

        try:""" % varinfo + """

   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 = None

   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

    _PySafeGetChanges_%(pyextname)s()

   234

    errors = []

   235

%(on_change_func_body)s

   236

    if len(errors)>0 :

   237

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

   238

   239

del __ext_name__

   240

   241

""" % loc_dict

   242

   243

        # write generated content to python file

   244

        runtimefile_path = os.path.join(buildpath,

   245

                                        "runtime_%s.py" % location_str)

   246

        runtimefile = open(runtimefile_path, 'wb')

   247

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

   248

        runtimefile.close()

   249

   250

        # C code for safe global variables access

   251

   252

        vardecfmt = """\

   253

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

   254

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

   255

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

   256

long __%(name)s_rlock = 0;

   257

long __%(name)s_wlock = 0;

   258

int __%(name)s_wbuffer_written = 0;

   259

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

   260

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

   261

    *pvalue = __%(name)s_rbuffer;

   262

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

   263

}

   264

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

   265

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

   266

    __%(name)s_wbuffer = *value;

   267

    __%(name)s_wbuffer_written = 1;

   268

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

   269

}

   270

   271

"""

   272

   273

        vardeconchangefmt = """\

   274

unsigned int __%(name)s_rbuffer_written = 0;

   275

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

   276

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

   277

unsigned int __%(name)s_onchange_count = 0;

   278

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

   279

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

   280

"""

   281

   282

        varretfmt = """\

   283

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

   284

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

   285

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

   286

            __%(name)s_wbuffer_written = 0;

   287

        }

   288

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

   289

    }

   290

"""

   291

        varpubfmt = """\

   292

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

   293

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

   294

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

   295

    }

   296

"""

   297

   298

        varpubonchangefmt = """\

   299

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

   300

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

   301

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

   302

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

   303

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

   304

            __%(name)s_rbuffer_lastval = tmp;

   305

            __%(name)s_rbuffer = tmp;

   306

            /* count one more change */

   307

            __%(name)s_rbuffer_written += 1;

   308

            some_change_found = 1;

   309

        }

   310

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

   311

    }

   312

"""

   313

   314

        varcollectchangefmt = """\

   315

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

   316

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

   317

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

   318

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

   319

    /* mark variable as unchanged */

   320

    __%(name)s_rbuffer_written = 0;

   321

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

   322

   323

"""

   324

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

   325

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

   326

                            for varinfo in varinfos])

   327

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

   328

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

   329

                             varpubfmt) % varinfo

   330

                            for varinfo in varinfos])

   331

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

   332

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

   333

   334

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

   335

   336

        loc_dict = {

   337

            "vardec": vardec,

   338

            "varret": varret,

   339

            "varpub": varpub,

   340

            "location_str": location_str,

   341

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

   342

            "pysafe_pypoll_code_len": len(pysafe_pypoll_code),

   343

            "varcollectchange": varcollectchange,

   344

            "onchange_var_count": onchange_var_count

   345

        }

   346

   347

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

   348

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

   349

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

   350

        PyCFileContent = """\

   351

/*

   352

 * Code generated by Beremiz py_ext confnode

   353

 * for safe global variables access

   354

 */

   355

#include "iec_types_all.h"

   356

#include "POUS.h"

   357

#include "config.h"

   358

#include "beremiz.h"

   359

   360

PYTHON_POLL* __%(location_str)s_notifier;

   361

   362

/* User variables reference */

   363

%(vardec)s

   364

   365

/* Beremiz confnode functions */

   366

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

   367

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

   368

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

   369

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

   370

   371

    return 0;

   372

}

   373

   374

void __cleanup_%(location_str)s(void){

   375

}

   376

   377

void __retrieve_%(location_str)s(void){

   378

%(varret)s

   379

}

   380

   381

static int passing_changes_to_python = 0;

   382

void __publish_%(location_str)s(void){

   383

    int some_change_found = 0;

   384

%(varpub)s

   385

    passing_changes_to_python |= some_change_found;

   386

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

   387

    if(passing_changes_to_python){

   388

        PYTHON_POLL_body__(__%(location_str)s_notifier);

   389

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

   390

    }

   391

}

   392

   393

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

   394

%(varcollectchange)s

   395

}

   396

   397

""" % loc_dict

   398

   399

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

   400

        pycfile = open(Gen_PyCfile_path, 'w')

   401

        pycfile.write(PyCFileContent)

   402

        pycfile.close()

   403

   404

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

   405

            self.GetCTRoot().GetIECLibPath())

   406

   407

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   408

                "",

   409

                True,

   410

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