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

import os, re

    27

from lxml import etree

    28

import util.paths as paths

    29

    30

from xmlclass import GenerateParserFromXSD

    31

    32

from CodeFileTreeNode import CodeFile

    33

from PythonEditor import PythonEditor

    34

    35

class PythonFileCTNMixin(CodeFile):

    36

    37

    CODEFILE_NAME = "PyFile"

    38

    SECTIONS_NAMES = [

    39

        "globals",

    40

        "init",

    41

        "cleanup",

    42

        "start",

    43

        "stop"]

    44

    EditorType = PythonEditor

    45

    46

    def __init__(self):

    47

        CodeFile.__init__(self)

    48

    49

        filepath = self.PythonFileName()

    50

    51

        if os.path.isfile(filepath):

    52

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

    53

    54

            xmlfile = open(filepath, 'r')

    55

            pythonfile_xml = xmlfile.read()

    56

            xmlfile.close()

    57

    58

            pythonfile_xml = pythonfile_xml.replace(

    59

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

    60

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

    61

            for cre, repl in [

    62

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

    63

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

    64

                pythonfile_xml = cre.sub(repl, pythonfile_xml)

    65

    66

            try:

    67

                python_code, error = PythonParser.LoadXMLString(pythonfile_xml)

    68

                if error is None:

    69

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

    70

                    os.remove(filepath)

    71

                    self.CreateCodeFileBuffer(False)

    72

                    self.OnCTNSave()

    73

            except Exception, exc:

    74

                error = unicode(exc)

    75

    76

            if error is not None:

    77

                self.GetCTRoot().logger.write_error(

    78

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

    79

    80

    def CodeFileName(self):

    81

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

    82

    83

    def PythonFileName(self):

    84

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

    85

    86

    PreSectionsTexts = {}

    87

    PostSectionsTexts = {}

    88

    def GetSection(self,section):

    89

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

    90

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

    91

               self.PostSectionsTexts.get(section,"")

    92

    93

    def CTNGenerate_C(self, buildpath, locations):

    94

        # location string for that CTN

    95

        location_str = "_".join(map(lambda x:str(x),

    96

                                self.GetCurrentLocation()))

    97

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

    98

    99

        pyextname = self.CTNName()

   100

        varinfos = map(lambda variable : {

   101

                    "name": variable.getname(),

   102

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

   103

                    "onchangecode" : '"'+variable.getonchange()+\

   104

                                         "('"+variable.getname()+"')\"" \

   105

                                     if variable.getonchange() else '""',

   106

                    "onchange" : repr(variable.getonchange()) \

   107

                                 if variable.getonchange() else None,

   108

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

   109

                    "configname" : configname.upper(),

   110

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

   111

                    "IECtype" : variable.gettype(),

   112

                    "pyextname" :pyextname},

   113

                    self.CodeFile.variables.variable)

   114

        # python side PLC global variables access stub

   115

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

   116

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

   117

    TypeTranslator["%(IECtype)s"]

   118

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

   119

_PySafeGetPLCGlob_%(name)s.restype = None

   120

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

   121

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

   122

_PySafeSetPLCGlob_%(name)s.restype = None

   123

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

   124

_%(pyextname)sGlobalsDesc.append((

   125

    "%(name)s",

   126

    "%(IECtype)s",

   127

    %(desc)s,

   128

    %(onchange)s,

   129

    %(opts)s))

   130

""" % varinfo

   131

      for varinfo in varinfos])

   132

   133

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

   134

        rtcalls = ""

   135

        for section in self.SECTIONS_NAMES:

   136

            if section != "globals":

   137

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

   138

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

   139

                if sectiontext:

   140

                    rtcalls += '    ' + \

   141

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

   142

                else:

   143

                    rtcalls += "    pass\n\n"

   144

   145

        globalsection = self.GetSection("globals")

   146

   147

        PyFileContent = """\

   148

#!/usr/bin/env python

   149

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

   150

## Code generated by Beremiz python mixin confnode

   151

##

   152

   153

## Code for PLC global variable access

   154

from targets.typemapping import TypeTranslator

   155

import ctypes

   156

_%(pyextname)sGlobalsDesc = []

   157

__ext_name__ = "%(pyextname)s"

   158

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

   159

%(globalstubs)s

   160

   161

## User code in "global" scope

   162

%(globalsection)s

   163

   164

## Beremiz python runtime calls

   165

%(rtcalls)s

   166

   167

del __ext_name__

   168

   169

""" % locals()

   170

   171

        # write generated content to python file

   172

        runtimefile_path = os.path.join(buildpath,

   173

            "runtime_%s.py"%location_str)

   174

        runtimefile = open(runtimefile_path, 'w')

   175

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

   176

        runtimefile.close()

   177

   178

        # C code for safe global variables access

   179

   180

        vardecfmt = """\

   181

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

   182

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

   183

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

   184

long __%(name)s_rlock = 0;

   185

long __%(name)s_wlock = 0;

   186

int __%(name)s_wbuffer_written = 0;

   187

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

   188

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

   189

    *pvalue = __%(name)s_rbuffer;

   190

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

   191

}

   192

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

   193

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

   194

    __%(name)s_wbuffer = *value;

   195

    __%(name)s_wbuffer_written = 1;

   196

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

   197

}

   198

   199

"""

   200

   201

        vardeconchangefmt = """\

   202

PYTHON_POLL* __%(name)s_notifier;

   203

"""

   204

   205

        varretfmt = """\

   206

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

   207

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

   208

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

   209

            __%(name)s_wbuffer_written = 0;

   210

        }

   211

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

   212

    }

   213

"""

   214

        varpubfmt = """\

   215

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

   216

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

   217

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

   218

    }

   219

"""

   220

   221

        varpubonchangefmt = """\

   222

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

   223

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

   224

        if(__%(name)s_rbuffer != tmp){

   225

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

   226

            PYTHON_POLL_body__(__%(name)s_notifier);

   227

        }

   228

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

   229

    }

   230

"""

   231

        varinitonchangefmt = """\

   232

    __%(name)s_notifier = __GET_GLOBAL_ON%(uppername)sCHANGE();

   233

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

   234

    __SET_VAR(__%(name)s_notifier->,CODE,,__STRING_LITERAL(%(onchangelen)d,%(onchangecode)s));

   235

"""

   236

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

   237

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

   238

                            for varinfo in varinfos])

   239

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

   240

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

   241

                             varpubfmt) % varinfo

   242

                            for varinfo in varinfos])

   243

        varinit = "\n".join([varinitonchangefmt % dict(

   244

                                onchangelen = len(varinfo["onchangecode"]),**varinfo)

   245

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

   246

   247

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

   248

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

   249

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

   250

        PyCFileContent = """\

   251

/*

   252

 * Code generated by Beremiz py_ext confnode

   253

 * for safe global variables access

   254

 */

   255

#include "iec_types_all.h"

   256

#include "POUS.h"

   257

#include "config.h"

   258

#include "beremiz.h"

   259

   260

/* User variables reference */

   261

%(vardec)s

   262

   263

/* Beremiz confnode functions */

   264

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

   265

%(varinit)s

   266

    return 0;

   267

}

   268

   269

void __cleanup_%(location_str)s(void){

   270

}

   271

   272

void __retrieve_%(location_str)s(void){

   273

%(varret)s

   274

}

   275

   276

void __publish_%(location_str)s(void){

   277

%(varpub)s

   278

}

   279

""" % locals()

   280

   281

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

   282

        pycfile = open(Gen_PyCfile_path,'w')

   283

        pycfile.write(PyCFileContent)

   284

        pycfile.close()

   285

   286

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

   287

            self.GetCTRoot().GetIECLibPath())

   288

   289

        return ([(Gen_PyCfile_path, matiec_CFLAGS)],

   290

                "",

   291

                True,

   292

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

   293