1

import os

     2

from PLCControler import UndoBuffer

     3

from PythonEditor import PythonEditor

     4

     5

from xml.dom import minidom

     6

from xmlclass import GenerateClassesFromXSD

     7

import cPickle

     8

     9

from CodeFileTreeNode import CodeFile

    10

    11

PythonClasses = GenerateClassesFromXSD(os.path.join(os.path.dirname(__file__), "py_ext_xsd.xsd")) 

    12

    13

class PythonFileCTNMixin(CodeFile):

    14

    15

    CODEFILE_NAME = "PyFile"

    16

    SECTIONS_NAMES = [

    17

        "globals",

    18

        "init",

    19

        "cleanup",

    20

        "start",

    21

        "stop"]

    22

    EditorType = PythonEditor

    23

    24

    def __init__(self):

    25

        CodeFile.__init__(self)

    26

    27

        filepath = self.PythonFileName()

    28

    29

        python_code = PythonClasses["Python"]()

    30

        if os.path.isfile(filepath):

    31

            xmlfile = open(filepath, 'r')

    32

            tree = minidom.parse(xmlfile)

    33

            xmlfile.close()

    34

    35

            for child in tree.childNodes:

    36

                if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "Python":

    37

                    python_code.loadXMLTree(child, ["xmlns", "xmlns:xsi", "xsi:schemaLocation"])

    38

                    self.CodeFile.globals.settext(python_code.gettext())

    39

                    os.remove(filepath)

    40

                    self.CreateCodeFileBuffer(False)

    41

                    self.OnCTNSave()

    42

    43

    def CodeFileName(self):

    44

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

    45

    46

    def PythonFileName(self):

    47

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

    48

    49

    PreSectionsTexts = {}

    50

    PostSectionsTexts = {}

    51

    def GetSection(self,section):

    52

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

    53

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

    54

               self.PostSectionsTexts.get(section,"")

    55

    56

    57

    def CTNGenerate_C(self, buildpath, locations):

    58

        # location string for that CTN 

    59

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

    60

                                self.GetCurrentLocation()))

    61

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

    62

    63

    64

        # python side PLC global variables access stub

    65

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

    66

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

    67

    TypeTranslator["%(IECtype)s"]

    68

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

    69

_PySafeGetPLCGlob_%(name)s.restype = None

    70

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

    71

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

    72

_PySafeSetPLCGlob_%(name)s.restype = None

    73

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

    74

""" % { "name": variable.getname(),

    75

        "configname": configname.upper(),

    76

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

    77

        "IECtype": variable.gettype()}

    78

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

    79

    80

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

    81

        rtcalls = ""

    82

        for section in self.SECTIONS_NAMES:

    83

            if section != "globals":

    84

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

    85

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

    86

                if sectiontext:

    87

                    rtcalls += '    ' + \

    88

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

    89

                else:

    90

                    rtcalls += "    pass\n\n"

    91

    92

        globalsection = self.GetSection("globals")      

    93

    94

        PyFileContent = """\

    95

#!/usr/bin/env python

    96

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

    97

## Code generated by Beremiz python mixin confnode

    98

##        

    99

   100

## Code for PLC global variable access

   101

from targets.typemapping import TypeTranslator

   102

import ctypes 

   103

%(globalstubs)s

   104

   105

## User code in "global" scope

   106

%(globalsection)s

   107

   108

## Beremiz python runtime calls

   109

%(rtcalls)s

   110

   111

""" % locals()

   112

   113

        # write generated content to python file

   114

        runtimefile_path = os.path.join(buildpath, 

   115

            "runtime_%s.py"%location_str)

   116

        runtimefile = open(runtimefile_path, 'w')

   117

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

   118

        runtimefile.close()

   119

   120

        # C code for safe global variables access

   121

   122

        vardecfmt = """\

   123

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

   124

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

   125

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

   126

long __%(name)s_rlock = 0;

   127

long __%(name)s_wlock = 0;

   128

int __%(name)s_wbuffer_written = 0;

   129

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

   130

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

   131

    *pvalue = __%(name)s_rbuffer;

   132

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

   133

}

   134

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

   135

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

   136

    __%(name)s_wbuffer = *value;

   137

    __%(name)s_wbuffer_written = 1;

   138

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

   139

}

   140

   141

"""

   142

        varretfmt = """\

   143

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

   144

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

   145

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

   146

            __%(name)s_wbuffer_written = 0;

   147

        }

   148

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

   149

    }

   150

""" 

   151

        varpubfmt = """\

   152

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

   153

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

   154

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

   155

    }

   156

""" 

   157

   158

        var_str = map("\n".join, zip(*[

   159

            map(lambda f : f % varinfo,

   160

                (vardecfmt, varretfmt, varpubfmt))

   161

                for varinfo in map(lambda variable : {

   162

                    "name": variable.getname(),

   163

                    "configname": configname.upper(),

   164

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

   165

                    "IECtype": variable.gettype()},

   166

                    self.CodeFile.variables.variable)]))

   167

        if len(var_str) > 0:

   168

            vardec, varret, varpub = var_str

   169

        else:

   170

            vardec = varret = varpub = ""

   171

   172

        PyCFileContent = """\

   173

/* 

   174

 * Code generated by Beremiz py_ext confnode 

   175

 * for safe global variables access

   176

 */

   177

#include "iec_types_all.h"

   178

#include "beremiz.h"

   179

   180

/* User variables reference */

   181

%(vardec)s

   182

   183

/* Beremiz confnode functions */

   184

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

   185

    return 0;

   186

}

   187

   188

void __cleanup_%(location_str)s(void){

   189

}

   190

   191

void __retrieve_%(location_str)s(void){

   192

%(varret)s

   193

}

   194

   195

void __publish_%(location_str)s(void){

   196

%(varpub)s

   197

}

   198

""" % locals()

   199

   200

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

   201

        pycfile = open(Gen_PyCfile_path,'w')

   202

        pycfile.write(PyCFileContent)

   203

        pycfile.close()

   204

   205

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

   206

            self.GetCTRoot().GetIECLibPath())

   207

   208

        return ([(Gen_PyCfile_path, matiec_flags)],

   209

                "",

   210

                True,

   211

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

   212