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, Lock, Semaphore

    27

import ctypes, os, commands, types, sys

    28

from targets.typemapping import SameEndianessTypeTranslator as TypeTranslator

    29

    30

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

    31

    from _ctypes import LoadLibrary as dlopen

    32

    from _ctypes import FreeLibrary as dlclose

    33

elif os.name == "posix":

    34

    from _ctypes import dlopen, dlclose

    35

    36

import traceback

    37

def get_last_traceback(tb):

    38

    while tb.tb_next:

    39

        tb = tb.tb_next

    40

    return tb

    41

    42

lib_ext ={

    43

     "linux2":".so",

    44

     "win32":".dll",

    45

     }.get(sys.platform, "")

    46

    47

def PLCprint(message):

    48

    sys.stdout.write("PLCobject : "+message+"\n")

    49

    sys.stdout.flush()

    50

    51

class PLCObject(pyro.ObjBase):

    52

    _Idxs = []

    53

    def __init__(self, workingdir, daemon, argv, statuschange, evaluator, website):

    54

        pyro.ObjBase.__init__(self)

    55

        self.evaluator = evaluator

    56

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

    57

        self.workingdir = workingdir

    58

        self.PLCStatus = "Stopped"

    59

        self.PLClibraryHandle = None

    60

        self.PLClibraryLock = Lock()

    61

        self.DummyIteratorLock = None

    62

        # Creates fake C funcs proxies

    63

        self._FreePLC()

    64

        self.daemon = daemon

    65

        self.statuschange = statuschange

    66

        self.hmi_frame = None

    67

        self.website = website

    68

    69

        # Get the last transfered PLC if connector must be restart

    70

        try:

    71

            self.CurrentPLCFilename=open(

    72

                             self._GetMD5FileName(),

    73

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

    74

        except Exception, e:

    75

            self.PLCStatus = "Empty"

    76

            self.CurrentPLCFilename=None

    77

    78

    def StatusChange(self):

    79

        if self.statuschange is not None:

    80

            self.statuschange(self.PLCStatus)

    81

    82

    def _GetMD5FileName(self):

    83

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

    84

    85

    def _GetLibFileName(self):

    86

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

    87

    88

    89

    def _LoadNewPLC(self):

    90

        """

    91

        Load PLC library

    92

        Declare all functions, arguments and return values

    93

        """

    94

        try:

    95

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

    96

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

    97

    98

            self._startPLC = self.PLClibraryHandle.startPLC

    99

            self._startPLC.restype = ctypes.c_int

   100

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

   101

   102

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   103

            self._stopPLC_real.restype = None

   104

   105

            self._PythonIterator = getattr(self.PLClibraryHandle, "PythonIterator", None)

   106

            if self._PythonIterator is not None:

   107

                self._PythonIterator.restype = ctypes.c_char_p

   108

                self._PythonIterator.argtypes = [ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]

   109

   110

                self._stopPLC = self._stopPLC_real

   111

            else:

   112

                # If python confnode is not enabled, we reuse _PythonIterator

   113

                # as a call that block pythonthread until StopPLC 

   114

                self.PythonIteratorLock = Lock()

   115

                self.PythonIteratorLock.acquire()

   116

                def PythonIterator(res, blkid):

   117

                    self.PythonIteratorLock.acquire()

   118

                    self.PythonIteratorLock.release()

   119

                    return None

   120

                self._PythonIterator = PythonIterator

   121

   122

                def __StopPLC():

   123

                    self._stopPLC_real()

   124

                    self.PythonIteratorLock.release()

   125

                self._stopPLC = __StopPLC

   126

   127

   128

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   129

            self._ResetDebugVariables.restype = None

   130

   131

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   132

            self._RegisterDebugVariable.restype = None

   133

            self._RegisterDebugVariable.argtypes = [ctypes.c_int, ctypes.c_void_p]

   134

   135

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   136

            self._FreeDebugData.restype = None

   137

   138

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   139

            self._GetDebugData.restype = ctypes.c_int  

   140

            self._GetDebugData.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_void_p)]

   141

   142

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   143

            self._suspendDebug.restype = ctypes.c_int

   144

            self._suspendDebug.argtypes = [ctypes.c_int]

   145

   146

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   147

            self._resumeDebug.restype = None

   148

   149

            return True

   150

        except:

   151

            PLCprint(traceback.format_exc())

   152

            return False

   153

   154

    def _FreePLC(self):

   155

        """

   156

        Unload PLC library.

   157

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

   158

        """

   159

        self.PLClibraryLock.acquire()

   160

        # Forget all refs to library

   161

        self._startPLC = lambda:None

   162

        self._stopPLC = lambda:None

   163

        self._ResetDebugVariables = lambda:None

   164

        self._RegisterDebugVariable = lambda x, y:None

   165

        self._IterDebugData = lambda x,y:None

   166

        self._FreeDebugData = lambda:None

   167

        self._GetDebugData = lambda:-1

   168

        self._suspendDebug = lambda x:-1

   169

        self._resumeDebug = lambda:None

   170

        self._PythonIterator = lambda:""

   171

        self.PLClibraryHandle = None

   172

        # Unload library explicitely

   173

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

   174

            dlclose(self._PLClibraryHandle)

   175

            self._PLClibraryHandle = None

   176

   177

        self.PLClibraryLock.release()

   178

        return False

   179

   180

    def PrepareRuntimePy(self):

   181

        self.python_threads_vars = globals().copy()

   182

        self.python_threads_vars["WorkingDir"] = self.workingdir

   183

        self.python_threads_vars["website"] = self.website

   184

        self.python_threads_vars["_runtime_begin"] = []

   185

        self.python_threads_vars["_runtime_cleanup"] = []

   186

        self.python_threads_vars["PLCObject"] = self

   187

        self.python_threads_vars["PLCBinary"] = self.PLClibraryHandle

   188

   189

        for filename in os.listdir(self.workingdir):

   190

            name, ext = os.path.splitext(filename)

   191

            if name.upper().startswith("RUNTIME") and ext.upper() == ".PY":

   192

                try:

   193

                    # TODO handle exceptions in runtime.py

   194

                    # pyfile may redefine _runtime_cleanup

   195

                    # or even call _PythonThreadProc itself.

   196

                    execfile(os.path.join(self.workingdir, filename), self.python_threads_vars)

   197

                except:

   198

                    PLCprint(traceback.format_exc())

   199

                runtime_begin = self.python_threads_vars.get("_%s_begin" % name, None)

   200

                if runtime_begin is not None:

   201

                    self.python_threads_vars["_runtime_begin"].append(runtime_begin)

   202

                runtime_cleanup = self.python_threads_vars.get("_%s_cleanup" % name, None)

   203

                if runtime_cleanup is not None:

   204

                    self.python_threads_vars["_runtime_cleanup"].append(runtime_cleanup)

   205

   206

        for runtime_begin in self.python_threads_vars.get("_runtime_begin", []):

   207

            runtime_begin()

   208

   209

        if self.website is not None:

   210

            self.website.PLCStarted()

   211

   212

    def FinishRuntimePy(self):

   213

        for runtime_cleanup in self.python_threads_vars.get("_runtime_cleanup", []):

   214

            runtime_cleanup()    

   215

        if self.website is not None:

   216

            self.website.PLCStopped()

   217

        self.python_threads_vars = None

   218

   219

    def PythonThreadProc(self):

   220

        self.PLCStatus = "Started"

   221

        self.StatusChange()

   222

        self.StartSem.release()

   223

        self.evaluator(self.PrepareRuntimePy)

   224

        res,cmd,blkid = "None","None",ctypes.c_void_p()

   225

        compile_cache={}

   226

        while True:

   227

            # print "_PythonIterator(", res, ")",

   228

            cmd = self._PythonIterator(res,blkid)

   229

            FBID = blkid.value 

   230

            # print " -> ", cmd, blkid

   231

            if cmd is None:

   232

                break

   233

            try :

   234

                self.python_threads_vars["FBID"]=FBID

   235

                ccmd,AST =compile_cache.get(FBID, (None,None))

   236

                if ccmd is None or ccmd!=cmd:

   237

                    AST = compile(cmd, '<plc>', 'eval')

   238

                    compile_cache[FBID]=(cmd,AST)

   239

                result,exp = self.evaluator(eval,cmd,self.python_threads_vars)

   240

                if exp is not None: 

   241

                    raise(exp)

   242

                else:

   243

                    res=str(result)

   244

                self.python_threads_vars["FBID"]=None

   245

            except Exception,e:

   246

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

   247

                PLCprint(('*** Python eval EXCEPTION ***\n'+

   248

                          '| Function Block ID: %d\n'+

   249

                          '| Command : "%s"\n'+

   250

                          '| Exception : "%s"')%(FBID,cmd,str(e)))

   251

        self.PLCStatus = "Stopped"

   252

        self.StatusChange()

   253

        self.evaluator(self.FinishRuntimePy)

   254

   255

    def StartPLC(self):

   256

        PLCprint("StartPLC")

   257

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

   258

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

   259

            error = None

   260

            if self._LoadNewPLC():

   261

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

   262

                    self.StartSem=Semaphore(0)

   263

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

   264

                    self.PythonThread.start()

   265

                    self.StartSem.acquire()

   266

                else:

   267

                    error = "starting"

   268

            else:

   269

                error = "loading"

   270

            if error is not None:

   271

                PLCprint("Problem %s PLC"%error)

   272

                self.PLCStatus = "Broken"

   273

                self.StatusChange()

   274

                self._FreePLC()

   275

   276

    def StopPLC(self):

   277

        PLCprint("StopPLC")

   278

        if self.PLCStatus == "Started":

   279

            self._stopPLC()

   280

            self.PythonThread.join()

   281

            self._FreePLC()

   282

            return True

   283

        return False

   284

   285

    def _Reload(self):

   286

        self.daemon.shutdown(True)

   287

        self.daemon.sock.close()

   288

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

   289

        # never reached

   290

        return 0

   291

   292

    def ForceReload(self):

   293

        # respawn python interpreter

   294

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

   295

        return True

   296

   297

    def GetPLCstatus(self):

   298

        return self.PLCStatus

   299

   300

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

   301

        PLCprint("NewPLC (%s)"%md5sum)

   302

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

   303

            NewFileName = md5sum + lib_ext

   304

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

   305

            try:

   306

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

   307

                                       self.CurrentPLCFilename))

   308

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

   309

                    try:

   310

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

   311

                    except:

   312

                        pass

   313

            except:

   314

                pass

   315

   316

            try:

   317

                # Create new PLC file

   318

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

   319

                     'wb').write(data)

   320

   321

                # Store new PLC filename based on md5 key

   322

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

   323

   324

                # Then write the files

   325

                log = file(extra_files_log, "w")

   326

                for fname,fdata in extrafiles:

   327

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

   328

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

   329

                    log.write(fname+'\n')

   330

   331

                # Store new PLC filename

   332

                self.CurrentPLCFilename = NewFileName

   333

            except:

   334

                PLCprint(traceback.format_exc())

   335

                return False

   336

            if self.PLCStatus == "Empty":

   337

                self.PLCStatus = "Stopped"

   338

            return True

   339

        return False

   340

   341

    def MatchMD5(self, MD5):

   342

        try:

   343

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

   344

            return last_md5 == MD5

   345

        except:

   346

            return False

   347

   348

   349

   350

    def SetTraceVariablesList(self, idxs):

   351

        """

   352

        Call ctype imported function to append 

   353

        these indexes to registred variables in PLC debugger

   354

        """

   355

        if idxs:

   356

            # suspend but dont disable

   357

            if self._suspendDebug(False) == 0:

   358

                # keep a copy of requested idx

   359

                self._Idxs = idxs[:]

   360

                self._ResetDebugVariables()

   361

                for idx,iectype,force in idxs:

   362

                    if force !=None:

   363

                        c_type,unpack_func, pack_func = \

   364

                            TypeTranslator.get(iectype,

   365

                                                    (None,None,None))

   366

                        force = ctypes.byref(pack_func(c_type,force)) 

   367

                    self._RegisterDebugVariable(idx, force)

   368

                self._resumeDebug()

   369

        else:

   370

            self._suspendDebug(True)

   371

            self._Idxs =  []

   372

   373

    def GetTraceVariables(self):

   374

        """

   375

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

   376

        """

   377

        if self.PLCStatus == "Started":

   378

            res=[]

   379

            tick = ctypes.c_uint32()

   380

            size = ctypes.c_uint32()

   381

            buffer = ctypes.c_void_p()

   382

            offset = 0

   383

            if self.PLClibraryLock.acquire(False):

   384

                if self._GetDebugData(ctypes.byref(tick),

   385

                                      ctypes.byref(size),

   386

                                      ctypes.byref(buffer)) == 0:

   387

                    if size.value:

   388

                        for idx, iectype, forced in self._Idxs:

   389

                            cursor = ctypes.c_void_p(buffer.value + offset)

   390

                            c_type,unpack_func, pack_func = \

   391

                                TypeTranslator.get(iectype,

   392

                                                        (None,None,None))

   393

                            if c_type is not None and offset < size.value:

   394

                                res.append(unpack_func(

   395

                                            ctypes.cast(cursor,

   396

                                             ctypes.POINTER(c_type)).contents))

   397

                                offset += ctypes.sizeof(c_type)

   398

                            else:

   399

                                if c_type is None:

   400

                                    PLCprint("Debug error - " + iectype +

   401

                                             " not supported !")

   402

                                #if offset >= size.value:

   403

                                    #PLCprint("Debug error - buffer too small ! %d != %d"%(offset, size.value))

   404

                                break

   405

                    self._FreeDebugData()

   406

                self.PLClibraryLock.release()

   407

            if offset and offset == size.value:

   408

                return self.PLCStatus, tick.value, res

   409

            #elif size.value:

   410

                #PLCprint("Debug error - wrong buffer unpack ! %d != %d"%(offset, size.value))

   411

        return self.PLCStatus, None, []

   412

   413

    def RemoteExec(self, script, **kwargs):

   414

        try:

   415

            exec script in kwargs

   416

        except:

   417

            e_type, e_value, e_traceback = sys.exc_info()

   418

            line_no = traceback.tb_lineno(get_last_traceback(e_traceback))

   419

            return (-1, "RemoteExec script failed!\n\nLine %d: %s\n\t%s" % 

   420

                        (line_no, e_value, script.splitlines()[line_no - 1]))

   421

        return (0, kwargs.get("returnVal", None))

   422

   423