1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz runtime.

     5

#

     6

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     7

#

     8

# See COPYING.Runtime file for copyrights details.

     9

#

    10

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

    11

# modify it under the terms of the GNU Lesser General Public

    12

# License as published by the Free Software Foundation; either

    13

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

    14

    15

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

    16

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

    17

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

    18

# Lesser General Public License for more details.

    19

    20

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

    21

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

    22

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

    23

    24

import Pyro.core as pyro

    25

from threading import Timer, Thread, Lock, Semaphore, Event

    26

import ctypes

    27

import os

    28

import commands

    29

import types

    30

import sys

    31

from targets.typemapping import LogLevelsDefault, LogLevelsCount, TypeTranslator, UnpackDebugBuffer

    32

from time import time

    33

    34

    35

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

    36

    from _ctypes import LoadLibrary as dlopen

    37

    from _ctypes import FreeLibrary as dlclose

    38

elif os.name == "posix":

    39

    from _ctypes import dlopen, dlclose

    40

    41

import traceback

    42

    43

    44

def get_last_traceback(tb):

    45

    while tb.tb_next:

    46

        tb = tb.tb_next

    47

    return tb

    48

    49

lib_ext ={

    50

     "linux2":".so",

    51

     "win32":".dll",

    52

     }.get(sys.platform, "")

    53

    54

    55

def PLCprint(message):

    56

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

    57

    sys.stdout.flush()

    58

    59

    60

class PLCObject(pyro.ObjBase):

    61

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

    62

        pyro.ObjBase.__init__(self)

    63

        self.evaluator = evaluator

    65

        self.workingdir = workingdir

    66

        self.PLCStatus = "Empty"

    67

        self.PLClibraryHandle = None

    68

        self.PLClibraryLock = Lock()

    69

        self.DummyIteratorLock = None

    70

        # Creates fake C funcs proxies

    71

        self._FreePLC()

    72

        self.daemon = daemon

    73

        self.statuschange = statuschange

    74

        self.hmi_frame = None

    75

        self.pyruntimevars = pyruntimevars

    76

        self._loading_error = None

    77

        self.python_runtime_vars = None

    78

        self.TraceThread = None

    79

        self.TraceLock = Lock()

    80

        self.TraceWakeup = Event()

    81

        self.Traces = []

    82

    83

    def AutoLoad(self):

    84

        # Get the last transfered PLC if connector must be restart

    85

        try:

    86

            self.CurrentPLCFilename=open(

    87

                             self._GetMD5FileName(),

    88

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

    89

            if self.LoadPLC():

    90

                self.PLCStatus = "Stopped"

    91

        except Exception, e:

    92

            self.PLCStatus = "Empty"

    93

            self.CurrentPLCFilename=None

    94

    95

    def StatusChange(self):

    96

        if self.statuschange is not None:

    97

            for callee in self.statuschange:

    98

                callee(self.PLCStatus)

    99

   100

    def LogMessage(self, *args):

   101

        if len(args) == 2:

   102

            level, msg = args

   103

        else:

   104

            level = LogLevelsDefault

   105

            msg, = args

   106

        return self._LogMessage(level, msg, len(msg))

   107

   108

    def ResetLogCount(self):

   109

        if self._ResetLogCount is not None:

   110

            self._ResetLogCount()

   111

   112

    def GetLogCount(self, level):

   113

        if self._GetLogCount is not None :

   114

            return int(self._GetLogCount(level))

   115

        elif self._loading_error is not None and level==0:

   116

            return 1

   117

   118

    def GetLogMessage(self, level, msgid):

   119

        tick = ctypes.c_uint32()

   120

        tv_sec = ctypes.c_uint32()

   121

        tv_nsec = ctypes.c_uint32()

   122

        if self._GetLogMessage is not None:

   123

            maxsz = len(self._log_read_buffer)-1

   124

            sz = self._GetLogMessage(level, msgid,

   125

                self._log_read_buffer, maxsz,

   126

                ctypes.byref(tick),

   127

                ctypes.byref(tv_sec),

   128

                ctypes.byref(tv_nsec))

   129

            if sz and sz <= maxsz:

   130

                self._log_read_buffer[sz] = '\x00'

   131

                return self._log_read_buffer.value,tick.value,tv_sec.value,tv_nsec.value

   132

        elif self._loading_error is not None and level==0:

   133

            return self._loading_error,0,0,0

   134

        return None

   135

   136

    def _GetMD5FileName(self):

   137

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

   138

   139

    def _GetLibFileName(self):

   140

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

   141

   142

   143

    def LoadPLC(self):

   144

        """

   145

        Load PLC library

   146

        Declare all functions, arguments and return values

   147

        """

   148

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

   149

        try:

   150

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

   151

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

   152

   153

            self.PLC_ID = ctypes.c_char_p.in_dll(self.PLClibraryHandle, "PLC_ID")

   154

            if len(md5) == 32 :

   155

                self.PLC_ID.value = md5

   156

   157

            self._startPLC = self.PLClibraryHandle.startPLC

   158

            self._startPLC.restype = ctypes.c_int

   159

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

   160

   161

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   162

            self._stopPLC_real.restype = None

   163

   164

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

   165

            if self._PythonIterator is not None:

   166

                self._PythonIterator.restype = ctypes.c_char_p

   167

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

   168

   169

                self._stopPLC = self._stopPLC_real

   170

            else:

   171

                # If python confnode is not enabled, we reuse _PythonIterator

   172

                # as a call that block pythonthread until StopPLC

   173

                self.PlcStopping = Event()

   174

                def PythonIterator(res, blkid):

   175

                    self.PlcStopping.clear()

   176

                    self.PlcStopping.wait()

   177

                    return None

   178

                self._PythonIterator = PythonIterator

   179

   180

                def __StopPLC():

   181

                    self._stopPLC_real()

   182

                    self.PlcStopping.set()

   183

                self._stopPLC = __StopPLC

   184

   185

   186

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   187

            self._ResetDebugVariables.restype = None

   188

   189

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   190

            self._RegisterDebugVariable.restype = None

   191

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

   192

   193

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   194

            self._FreeDebugData.restype = None

   195

   196

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   197

            self._GetDebugData.restype = ctypes.c_int

   198

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

   199

   200

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   201

            self._suspendDebug.restype = ctypes.c_int

   202

            self._suspendDebug.argtypes = [ctypes.c_int]

   203

   204

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   205

            self._resumeDebug.restype = None

   206

   207

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   208

            self._ResetLogCount.restype = None

   209

   210

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   211

            self._GetLogCount.restype = ctypes.c_uint32

   212

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   213

   214

            self._LogMessage = self.PLClibraryHandle.LogMessage

   215

            self._LogMessage.restype = ctypes.c_int

   216

            self._LogMessage.argtypes = [ctypes.c_uint8, ctypes.c_char_p, ctypes.c_uint32]

   217

   219

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   220

            self._GetLogMessage.restype = ctypes.c_uint32

   221

            self._GetLogMessage.argtypes = [ctypes.c_uint8, ctypes.c_uint32, ctypes.c_char_p, ctypes.c_uint32, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32)]

   222

   223

            self._loading_error = None

   224

   225

            self.PythonRuntimeInit()

   226

   227

            return True

   228

        except:

   229

            self._loading_error = traceback.format_exc()

   230

            PLCprint(self._loading_error)

   231

            return False

   232

   233

    def UnLoadPLC(self):

   234

        self.PythonRuntimeCleanup()

   235

        self._FreePLC()

   236

   237

    def _FreePLC(self):

   238

        """

   239

        Unload PLC library.

   240

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

   241

        """

   242

        self.PLClibraryLock.acquire()

   243

        # Forget all refs to library

   244

        self._startPLC = lambda x,y:None

   245

        self._stopPLC = lambda:None

   246

        self._ResetDebugVariables = lambda:None

   247

        self._RegisterDebugVariable = lambda x, y:None

   248

        self._IterDebugData = lambda x,y:None

   249

        self._FreeDebugData = lambda:None

   250

        self._GetDebugData = lambda:-1

   251

        self._suspendDebug = lambda x:-1

   252

        self._resumeDebug = lambda:None

   253

        self._PythonIterator = lambda:""

   254

        self._GetLogCount = None

   255

        self._LogMessage = lambda l,m,s:PLCprint("OFF LOG :"+m)

   256

        self._GetLogMessage = None

   257

        self.PLClibraryHandle = None

   258

        # Unload library explicitely

   259

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

   260

            dlclose(self._PLClibraryHandle)

   261

            self._PLClibraryHandle = None

   262

   263

        self.PLClibraryLock.release()

   264

        return False

   265

   266

    def PythonRuntimeCall(self, methodname):

   267

        """

   268

        Calls init, start, stop or cleanup method provided by

   269

        runtime python files, loaded when new PLC uploaded

   270

        """

   271

        for method in self.python_runtime_vars.get("_runtime_%s" % methodname, []):

   272

            res,exp = self.evaluator(method)

   273

            if exp is not None:

   274

                self.LogMessage(0,'\n'.join(traceback.format_exception(*exp)))

   275

   276

    def PythonRuntimeInit(self):

   277

        MethodNames = ["init", "start", "stop", "cleanup"]

   278

        self.python_runtime_vars = globals().copy()

   279

        self.python_runtime_vars.update(self.pyruntimevars)

   280

   281

        class PLCSafeGlobals:

   282

            def __getattr__(_self, name):

   283

                try :

   284

                    t = self.python_runtime_vars["_"+name+"_ctype"]

   285

                except KeyError:

   286

                    raise KeyError("Try to get unknown shared global variable : %s" % name)

   287

                v = t()

   288

                r = self.python_runtime_vars["_PySafeGetPLCGlob_"+name](ctypes.byref(v))

   289

                return self.python_runtime_vars["_"+name+"_unpack"](v)

   290

            def __setattr__(_self, name, value):

   291

                try :

   292

                    t = self.python_runtime_vars["_"+name+"_ctype"]

   293

                except KeyError:

   294

                    raise KeyError("Try to set unknown shared global variable : %s" % name)

   295

                v = self.python_runtime_vars["_"+name+"_pack"](t,value)

   296

                self.python_runtime_vars["_PySafeSetPLCGlob_"+name](ctypes.byref(v))

   297

   298

        self.python_runtime_vars.update({

   299

            "PLCGlobals" : PLCSafeGlobals(),

   300

            "WorkingDir" : self.workingdir,

   301

            "PLCObject"  : self,

   302

            "PLCBinary"  : self.PLClibraryHandle,

   303

            "PLCGlobalsDesc" : []})

   304

   305

        for methodname in MethodNames :

   306

            self.python_runtime_vars["_runtime_%s" % methodname] = []

   307

   308

        try:

   309

            filenames = os.listdir(self.workingdir)

   310

            filenames.sort()

   311

            for filename in filenames:

   312

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

   313

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

   314

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

   315

                    for methodname in MethodNames:

   316

                        method = self.python_runtime_vars.get("_%s_%s" % (name, methodname), None)

   317

                        if method is not None:

   318

                            self.python_runtime_vars["_runtime_%s" % methodname].append(method)

   319

        except:

   320

            self.LogMessage(0,traceback.format_exc())

   321

            raise

   322

   323

        self.PythonRuntimeCall("init")

   324

   325

   326

   327

    def PythonRuntimeCleanup(self):

   328

        if self.python_runtime_vars is not None:

   329

            self.PythonRuntimeCall("cleanup")

   330

   331

        self.python_runtime_vars = None

   332

   333

    def PythonThreadProc(self):

   334

        self.StartSem.release()

   335

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

   336

        compile_cache={}

   337

        while True:

   338

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

   339

            cmd = self._PythonIterator(res,blkid)

   340

            FBID = blkid.value

   341

            # print " -> ", cmd, blkid

   342

            if cmd is None:

   343

                break

   344

            try :

   345

                self.python_runtime_vars["FBID"]=FBID

   346

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

   347

                if ccmd is None or ccmd!=cmd:

   348

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

   349

                    compile_cache[FBID]=(cmd,AST)

   350

                result,exp = self.evaluator(eval,AST,self.python_runtime_vars)

   351

                if exp is not None:

   352

                    res = "#EXCEPTION : "+str(exp[1])

   353

                    self.LogMessage(1,('PyEval@0x%x(Code="%s") Exception "%s"') % (FBID,cmd,

   354

                        '\n'.join(traceback.format_exception(*exp))))

   355

                else:

   356

                    res=str(result)

   357

                self.python_runtime_vars["FBID"]=None

   358

            except Exception,e:

   359

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

   360

                self.LogMessage(1,('PyEval@0x%x(Code="%s") Exception "%s"') % (FBID,cmd,str(e)))

   361

   362

    def StartPLC(self):

   363

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

   364

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

   365

            error = None

   366

            res = self._startPLC(len(self.argv),c_argv(*self.argv))

   367

            if res == 0:

   368

                self.PLCStatus = "Started"

   369

                self.StatusChange()

   370

                self.PythonRuntimeCall("start")

   371

                self.StartSem=Semaphore(0)

   372

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

   373

                self.PythonThread.start()

   374

                self.StartSem.acquire()

   375

                self.LogMessage("PLC started")

   376

            else:

   377

                self.LogMessage(0,_("Problem starting PLC : error %d" % res))

   378

                self.PLCStatus = "Broken"

   379

                self.StatusChange()

   380

   381

    def StopPLC(self):

   382

        if self.PLCStatus == "Started":

   383

            self.LogMessage("PLC stopped")

   384

            self._stopPLC()

   385

            self.PythonThread.join()

   386

            self.PLCStatus = "Stopped"

   387

            self.StatusChange()

   388

            self.PythonRuntimeCall("stop")

   389

            if self.TraceThread is not None :

   390

                self.TraceWakeup.set()

   391

                self.TraceThread.join()

   392

                self.TraceThread = None

   393

            return True

   394

        return False

   395

   396

    def _Reload(self):

   397

        self.daemon.shutdown(True)

   398

        self.daemon.sock.close()

   399

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

   400

        # never reached

   401

        return 0

   402

   403

    def ForceReload(self):

   404

        # respawn python interpreter

   405

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

   406

        return True

   407

   408

    def GetPLCstatus(self):

   409

        return self.PLCStatus, map(self.GetLogCount,xrange(LogLevelsCount))

   410

   411

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

   412

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

   413

            NewFileName = md5sum + lib_ext

   414

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

   415

   416

            self.UnLoadPLC()

   417

   418

            self.LogMessage("NewPLC (%s)" % md5sum)

   419

            self.PLCStatus = "Empty"

   420

   421

            try:

   422

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

   423

                                       self.CurrentPLCFilename))

   424

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

   425

                    try:

   426

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

   427

                    except:

   428

                        pass

   429

            except:

   430

                pass

   431

   432

            try:

   433

                # Create new PLC file

   434

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

   435

                     'wb').write(data)

   436

   437

                # Store new PLC filename based on md5 key

   438

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

   439

   440

                # Then write the files

   441

                log = file(extra_files_log, "w")

   442

                for fname,fdata in extrafiles:

   443

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

   444

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

   445

                    log.write(fname+'\n')

   446

   447

                # Store new PLC filename

   448

                self.CurrentPLCFilename = NewFileName

   449

            except:

   450

                self.PLCStatus = "Broken"

   451

                self.StatusChange()

   452

                PLCprint(traceback.format_exc())

   453

                return False

   454

   455

            if self.LoadPLC():

   456

                self.PLCStatus = "Stopped"

   457

            else:

   458

                self.PLCStatus = "Broken"

   459

                self._FreePLC()

   460

            self.StatusChange()

   461

   462

            return self.PLCStatus == "Stopped"

   463

        return False

   464

   465

    def MatchMD5(self, MD5):

   466

        try:

   467

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

   468

            return last_md5 == MD5

   469

        except:

   470

            pass

   471

        return False

   472

   473

    def SetTraceVariablesList(self, idxs):

   474

        """

   475

        Call ctype imported function to append

   476

        these indexes to registred variables in PLC debugger

   477

        """

   478

        if idxs:

   479

            # suspend but dont disable

   480

            if self._suspendDebug(False) == 0: