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

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library is distributed in the hope that it will be useful,

    17

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

import Pyro.core as pyro

    26

from threading import Timer, Thread

    27

import ctypes, os, commands

    28

    29

if os.name in ("nt", "ce"):

    30

    from _ctypes import LoadLibrary as dlopen

    31

    from _ctypes import FreeLibrary as dlclose

    32

elif os.name == "posix":

    33

    from _ctypes import dlopen, dlclose

    34

    35

import os,sys,traceback

    36

    37

lib_ext ={

    38

     "linux2":".so",

    39

     "win32":".dll",

    40

     }.get(sys.platform, "")

    41

    42

class PLCObject(pyro.ObjBase):

    43

    _Idxs = []

    44

    def __init__(self, workingdir, daemon, argv, statuschange=None):

    45

        pyro.ObjBase.__init__(self)

    46

        self.argv = [workingdir] + argv # force argv[0] to be "path" to exec...

    47

        self.workingdir = workingdir

    48

        self.PLCStatus = "Stopped"

    49

        self.PLClibraryHandle = None

    50

        # Creates fake C funcs proxies

    51

        self._FreePLC()

    52

        self.daemon = daemon

    53

        self.statuschange = statuschange

    54

    55

        # Get the last transfered PLC if connector must be restart

    56

        try:

    57

            self.CurrentPLCFilename=open(

    58

                             self._GetMD5FileName(),

    59

                             "r").read().strip() + lib_ext

    60

        except Exception, e:

    61

            self.PLCStatus = "Empty"

    62

            self.CurrentPLCFilename=None

    63

    64

    def _GetMD5FileName(self):

    65

        return os.path.join(self.workingdir, "lasttransferedPLC.md5")

    66

    67

    def _GetLibFileName(self):

    68

        return os.path.join(self.workingdir,self.CurrentPLCFilename)

    69

    70

    71

    def _LoadNewPLC(self):

    72

        """

    73

        Load PLC library

    74

        Declare all functions, arguments and return values

    75

        """

    76

        print "Load PLC"

    77

        try:

    78

            self._PLClibraryHandle = dlopen(self._GetLibFileName())

    79

            self.PLClibraryHandle = ctypes.CDLL(self.CurrentPLCFilename, handle=self._PLClibraryHandle)

    80

    81

            self._startPLC = self.PLClibraryHandle.startPLC

    82

            self._startPLC.restype = ctypes.c_int

    83

            self._startPLC.argtypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_char_p)]

    84

    85

            self._stopPLC = self.PLClibraryHandle.stopPLC

    86

            self._stopPLC.restype = None

    87

    88

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

    89

            self._ResetDebugVariables.restype = None

    90

    91

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

    92

            self._RegisterDebugVariable.restype = None

    93

            self._RegisterDebugVariable.argtypes = [ctypes.c_int]

    94

    95

            self._IterDebugData = self.PLClibraryHandle.IterDebugData

    96

            self._IterDebugData.restype = ctypes.c_void_p

    97

            self._IterDebugData.argtypes = [ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_char_p)]

    98

    99

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   100

            self._FreeDebugData.restype = None

   101

   102

            self._WaitDebugData = self.PLClibraryHandle.WaitDebugData

   103

            self._WaitDebugData.restype = ctypes.c_int  

   104

   105

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   106

            self._suspendDebug.restype = None

   107

   108

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   109

            self._resumeDebug.restype = None

   110

   111

            self._PythonIterator = self.PLClibraryHandle.PythonIterator

   112

            self._PythonIterator.restype = ctypes.c_char_p

   113

            self._PythonIterator.argtypes = [ctypes.c_char_p]

   114

   115

            return True

   116

        except:

   117

            print traceback.format_exc()

   118

            return False

   119

   120

    def _FreePLC(self):

   121

        """

   122

        Unload PLC library.

   123

        This is also called by __init__ to create dummy C func proxies

   124

        """

   125

        # Forget all refs to library

   126

        self._startPLC = lambda:None

   127

        self._stopPLC = lambda:None

   128

        self._ResetDebugVariables = lambda:None

   129

        self._RegisterDebugVariable = lambda x:None

   130

        self._IterDebugData = lambda x,y:None

   131

        self._FreeDebugData = lambda:None

   132

        self._WaitDebugData = lambda:-1

   133

        self._suspendDebug = lambda:None

   134

        self._resumeDebug = lambda:None

   135

        self._PythonIterator = lambda:""

   136

        self.PLClibraryHandle = None

   137

        # Unload library explicitely

   138

        if getattr(self,"_PLClibraryHandle",None) is not None:

   139

            print "Unload PLC"

   140

            dlclose(self._PLClibraryHandle)

   141

            res = self._DetectDirtyLibs()

   142

        else:

   143

            res = False

   144

   145

        self._PLClibraryHandle = None

   146

   147

        return res

   148

   149

    def _DetectDirtyLibs(self):

   150

        # Detect dirty libs

   151

        # Get lib dependencies (for dirty lib detection)

   152

        if os.name == "posix":

   153

            # parasiting libs listed with ldd

   154

            badlibs = [ toks.split()[0] for toks in commands.getoutput(

   155

                            "ldd "+self._GetLibFileName()).splitlines() ]

   156

            for badlib in badlibs:

   157

                if badlib[:6] in ["libwx_",

   158

                                  "libwxs",

   159

                                  "libgtk",

   160

                                  "libgdk",

   161

                                  "libatk",

   162

                                  "libpan",

   163

                                  "libX11",

   164

                                  ]:

   165

                    #badhandle = dlopen(badlib, dl.RTLD_NOLOAD)

   166

                    print "Dirty lib detected :" + badlib

   167

                    #dlclose(badhandle)

   168

                    return True

   169

        return False

   170

   171

    def PythonThreadProc(self):

   176

        res = ""

   177

        print "PythonThreadProc started"

   178

        while self.PLCStatus == "Started":

   179

            cmd = self._PythonIterator(res)

   181

            try :

   182

                res = eval(cmd)

   183

            except Exception,e:

   184

                res = "#EXCEPTION : "+str(e)

   185

                print res

   186

        print "PythonThreadProc finished"

   187

   188

    def StartPLC(self, debug=False):

   189

        print "StartPLC"

   190

        if self.CurrentPLCFilename is not None and self.PLCStatus == "Stopped":

   191

            c_argv = ctypes.c_char_p * len(self.argv)

   192

            if self._LoadNewPLC() and self._startPLC(len(self.argv),c_argv(*self.argv)) == 0:

   193

                if debug:

   194

                    self._resumeDebug()

   195

                self.PLCStatus = "Started"

   196

                if self.statuschange is not None:

   197

                    self.statuschange(self.PLCStatus)

   198

                self.PythonThread = Thread(target=self.PythonThreadProc)

   199

                self.PythonThread.start()

   200

                return True

   201

            else:

   202

                print "_StartPLC did not return 0 !"

   203

                self._DoStopPLC()

   204

        return False

   205

   206

    def _DoStopPLC(self):

   207

        self._stopPLC()

   208

        self.PLCStatus = "Stopped"

   209

        if self.statuschange is not None:

   210

            self.statuschange(self.PLCStatus)

   211

        if self._FreePLC():

   212

            self.PLCStatus = "Dirty"

   213

        return True

   214

   215

    def StopPLC(self):

   216

        if self.PLCStatus == "Started":

   217

            self._DoStopPLC()

   218

            return True

   219

        return False

   220

   221

    def _Reload(self):

   222

        self.daemon.shutdown(True)

   223

        self.daemon.sock.close()

   224

        os.execv(sys.executable,[sys.executable]+sys.argv[:])

   225

        # never reached

   226

        return 0

   227

   228

    def ForceReload(self):

   229

        # respawn python interpreter

   230

        Timer(0.1,self._Reload).start()

   231

        return True

   232

   233

    def GetPLCstatus(self):

   234

        return self.PLCStatus

   235

   236

    def NewPLC(self, md5sum, data, extrafiles):

   237

        print "NewPLC (%s)"%md5sum

   238

        if self.PLCStatus in ["Stopped", "Empty", "Dirty"]:

   239

            NewFileName = md5sum + lib_ext

   240

            extra_files_log = os.path.join(self.workingdir,"extra_files.txt")

   241

            try:

   242

                os.remove(os.path.join(self.workingdir,

   243

                                       self.CurrentPLCFilename))

   244

                for filename in file(extra_files_log, "r").readlines() + extra_files_log:

   245

                    try:

   246

                        os.remove(os.path.join(self.workingdir, filename))

   247

                    except:

   248

                        pass

   249

            except:

   250

                pass

   251

   252

            try:

   253

                # Create new PLC file

   254

                open(os.path.join(self.workingdir,NewFileName),

   255

                     'wb').write(data)

   256

   257

                # Store new PLC filename based on md5 key

   258

                open(self._GetMD5FileName(), "w").write(md5sum)

   259

   260

                # Then write the files

   261

                log = file(extra_files_log, "w")

   262

                for fname,fdata in extrafiles:

   263

                    fpath = os.path.join(self.workingdir,fname)

   264

                    open(fpath, "wb").write(fdata)

   265

                    log.write(fname+'\n')

   266

   267

                # Store new PLC filename

   268

                self.CurrentPLCFilename = NewFileName

   269

            except:

   270

                print traceback.format_exc()

   271

                return False

   272

            if self.PLCStatus == "Empty":

   273

                self.PLCStatus = "Stopped"

   274

            return True

   275

        return False

   276

   277

    def MatchMD5(self, MD5):

   278

        try:

   279

            last_md5 = open(self._GetMD5FileName(), "r").read()

   280

            return last_md5 == MD5

   281

        except:

   282

            return False

   283

   284

    def SetTraceVariablesList(self, idxs):

   285

        """

   286

        Call ctype imported function to append 

   287

        these indexes to registred variables in PLC debugger

   288

        """

   289

        self._suspendDebug()

   290

        # keep a copy of requested idx

   291

        self._Idxs = idxs[:]

   292

        self._ResetDebugVariables()

   293

        for idx in idxs:

   294

            self._RegisterDebugVariable(idx)

   295

        self._resumeDebug()

   296

   297

    class IEC_STRING(ctypes.Structure):

   298

        """

   299

        Must be changed according to changes in iec_types.h

   300

        """

   301

        _fields_ = [("len", ctypes.c_uint8),

   302

                    ("body", ctypes.c_char * 40)] 

   303

   304

    TypeTranslator = {"BOOL" :       (ctypes.c_uint8, lambda x:x.value!=0),

   305

                      "STEP" :       (ctypes.c_uint8, lambda x:x.value),

   306

                      "TRANSITION" : (ctypes.c_uint8, lambda x:x.value),

   307

                      "ACTION" :     (ctypes.c_uint8, lambda x:x.value),

   308

                      "SINT" :       (ctypes.c_int8, lambda x:x.value),

   309

                      "USINT" :      (ctypes.c_uint8, lambda x:x.value),

   310

                      "BYTE" :       (ctypes.c_uint8, lambda x:x.value),

   311

                      "STRING" :     (IEC_STRING, lambda x:x.body[:x.len]),

   312

                      "INT" :        (ctypes.c_int16, lambda x:x.value),

   313

                      "UINT" :       (ctypes.c_uint16, lambda x:x.value),

   314

                      "WORD" :       (ctypes.c_uint16, lambda x:x.value),

   315

                      "WSTRING" :    (None, None),#TODO

   316

                      "DINT" :       (ctypes.c_int32, lambda x:x.value),

   317

                      "UDINT" :      (ctypes.c_uint32, lambda x:x.value),

   318

                      "DWORD" :      (ctypes.c_uint32, lambda x:x.value),

   319

                      "LINT" :       (ctypes.c_int64, lambda x:x.value),

   320

                      "ULINT" :      (ctypes.c_uint64, lambda x:x.value),

   321

                      "LWORD" :      (ctypes.c_uint64, lambda x:x.value),

   322

                      "REAL" :       (ctypes.c_float, lambda x:x.value),

   323

                      "LREAL" :      (ctypes.c_double, lambda x:x.value),

   324

                      } 

   325

   326

    def GetTraceVariables(self):

   327

        """

   328

        Return a list of variables, corresponding to the list of requiered idx

   329

        """

   330

        tick = self._WaitDebugData()

   331

        if tick == -1:

   332

            res = None

   333

        else:

   334

            idx = ctypes.c_int()

   335

            typename = ctypes.c_char_p()

   336

            res = []

   337

   338

            for given_idx in self._Idxs:

   339

                buffer=self._IterDebugData(ctypes.byref(idx), ctypes.byref(typename))

   340

                c_type,unpack_func = self.TypeTranslator.get(typename.value, (None,None))

   341

                if c_type is not None and given_idx == idx.value:

   342

                    res.append(unpack_func(ctypes.cast(buffer,

   343

                                                       ctypes.POINTER(c_type)).contents))

   344

                else:

   345

                    print "Debug error idx : %d, expected_idx %d, type : %s"%(idx.value, given_idx,typename.value)

   346

                    res.append(None)

   347

        self._FreeDebugData()

   348

        return tick, res

   349

   350

   351