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

    64

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

    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

    def LoadPLC(self):

   143

        """

   144

        Load PLC library

   145

        Declare all functions, arguments and return values

   146

        """

   147

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

   148

        try:

   149

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

   150

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

   151

   152

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

   153

            if len(md5) == 32:

   154

                self.PLC_ID.value = md5

   155

   156

            self._startPLC = self.PLClibraryHandle.startPLC

   157

            self._startPLC.restype = ctypes.c_int

   158

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

   159

   160

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   161

            self._stopPLC_real.restype = None

   162

   163

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

   164

            if self._PythonIterator is not None:

   165

                self._PythonIterator.restype = ctypes.c_char_p

   166

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

   167

   168

                self._stopPLC = self._stopPLC_real

   169

            else:

   170

                # If python confnode is not enabled, we reuse _PythonIterator

   171

                # as a call that block pythonthread until StopPLC

   172

                self.PlcStopping = Event()

   173

                def PythonIterator(res, blkid):

   174

                    self.PlcStopping.clear()

   175

                    self.PlcStopping.wait()

   176

                    return None

   177

                self._PythonIterator = PythonIterator

   178

   179

                def __StopPLC():

   180

                    self._stopPLC_real()

   181

                    self.PlcStopping.set()

   182

                self._stopPLC = __StopPLC

   183

   184

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   185

            self._ResetDebugVariables.restype = None

   186

   187

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   188

            self._RegisterDebugVariable.restype = None

   189

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

   190

   191

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   192

            self._FreeDebugData.restype = None

   193

   194

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   195

            self._GetDebugData.restype = ctypes.c_int

   196

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

   197

   198

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   199

            self._suspendDebug.restype = ctypes.c_int

   200

            self._suspendDebug.argtypes = [ctypes.c_int]

   201

   202

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   203

            self._resumeDebug.restype = None

   204

   205

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   206

            self._ResetLogCount.restype = None

   207

   208

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   209

            self._GetLogCount.restype = ctypes.c_uint32

   210

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   211

   212

            self._LogMessage = self.PLClibraryHandle.LogMessage

   213

            self._LogMessage.restype = ctypes.c_int

   214

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

   215

   216

            self._log_read_buffer = ctypes.create_string_buffer(1<<14)  #16K

   217

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   218

            self._GetLogMessage.restype = ctypes.c_uint32

   219

            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)]

   220

   221

            self._loading_error = None

   222

   223

            self.PythonRuntimeInit()

   224

   225

            return True

   226

        except:

   227

            self._loading_error = traceback.format_exc()

   228

            PLCprint(self._loading_error)

   229

            return False

   230

   231

    def UnLoadPLC(self):

   232

        self.PythonRuntimeCleanup()

   233

        self._FreePLC()

   234

   235

    def _FreePLC(self):

   236

        """

   237

        Unload PLC library.

   238

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

   239

        """

   240

        self.PLClibraryLock.acquire()

   241

        # Forget all refs to library

   242

        self._startPLC = lambda x, y: None

   243

        self._stopPLC = lambda: None

   244

        self._ResetDebugVariables = lambda: None

   245

        self._RegisterDebugVariable = lambda x, y: None

   246

        self._IterDebugData = lambda x, y: None

   247

        self._FreeDebugData = lambda: None

   248

        self._GetDebugData = lambda: -1

   249

        self._suspendDebug = lambda x: -1

   250

        self._resumeDebug = lambda: None

   251

        self._PythonIterator = lambda: ""

   252

        self._GetLogCount = None

   253

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

   254

        self._GetLogMessage = None

   255

        self.PLClibraryHandle = None

   256

        # Unload library explicitely

   257

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

   258

            dlclose(self._PLClibraryHandle)

   259

            self._PLClibraryHandle = None

   260

   261

        self.PLClibraryLock.release()

   262

        return False

   263

   264

    def PythonRuntimeCall(self, methodname):

   265

        """

   266

        Calls init, start, stop or cleanup method provided by

   267

        runtime python files, loaded when new PLC uploaded

   268

        """

   269

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

   270

            res, exp = self.evaluator(method)

   271

            if exp is not None:

   272

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

   273

   274

    def PythonRuntimeInit(self):

   275

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

   276

        self.python_runtime_vars = globals().copy()

   277

        self.python_runtime_vars.update(self.pyruntimevars)

   278

   279

        class PLCSafeGlobals:

   280

            def __getattr__(_self, name):

   281

                try:

   282

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

   283

                except KeyError:

   284

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

   285

                v = t()

   286

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

   287

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

   288

            def __setattr__(_self, name, value):

   289

                try:

   290

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

   291

                except KeyError:

   292

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

   293

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

   294

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

   295

   296

        self.python_runtime_vars.update({

   297

            "PLCGlobals":     PLCSafeGlobals(),

   298

            "WorkingDir":     self.workingdir,

   299

            "PLCObject":      self,

   300

            "PLCBinary":      self.PLClibraryHandle,

   301

            "PLCGlobalsDesc": []})

   302

   303

        for methodname in MethodNames:

   304

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

   305

   306

        try:

   307

            filenames = os.listdir(self.workingdir)

   308

            filenames.sort()

   309

            for filename in filenames:

   310

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

   311

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

   312

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

   313

                    for methodname in MethodNames:

   314

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

   315

                        if method is not None:

   316

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

   317

        except:

   318

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

   319

            raise

   320

   321

        self.PythonRuntimeCall("init")

   322

   323

    def PythonRuntimeCleanup(self):

   324

        if self.python_runtime_vars is not None:

   325

            self.PythonRuntimeCall("cleanup")

   326

   327

        self.python_runtime_vars = None

   328

   329

    def PythonThreadProc(self):

   330

        self.StartSem.release()

   331

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

   332

        compile_cache = {}

   333

        while True:

   334

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

   335

            cmd = self._PythonIterator(res, blkid)

   336

            FBID = blkid.value

   337

            # print " -> ", cmd, blkid

   338

            if cmd is None:

   339

                break

   340

            try:

   341

                self.python_runtime_vars["FBID"] = FBID

   342

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

   343

                if ccmd is None or ccmd != cmd:

   344

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

   345

                    compile_cache[FBID] = (cmd, AST)

   346

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

   347

                if exp is not None:

   348

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

   349

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

   350

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

   351

                else:

   352

                    res = str(result)

   353

                self.python_runtime_vars["FBID"] = None

   354

            except Exception, e:

   355

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

   356

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

   357

   358

    def StartPLC(self):

   359

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

   360

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

   361

            error = None

   362

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

   363

            if res == 0:

   364

                self.PLCStatus = "Started"

   365

                self.StatusChange()

   366

                self.PythonRuntimeCall("start")

   367

                self.StartSem = Semaphore(0)

   368

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

   369

                self.PythonThread.start()

   370

                self.StartSem.acquire()

   371

                self.LogMessage("PLC started")

   372

            else:

   373

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

   374

                self.PLCStatus = "Broken"

   375

                self.StatusChange()

   376

   377

    def StopPLC(self):

   378

        if self.PLCStatus == "Started":

   379

            self.LogMessage("PLC stopped")

   380

            self._stopPLC()

   381

            self.PythonThread.join()

   382

            self.PLCStatus = "Stopped"

   383

            self.StatusChange()

   384

            self.PythonRuntimeCall("stop")

   385

            if self.TraceThread is not None:

   386

                self.TraceWakeup.set()

   387

                self.TraceThread.join()

   388

                self.TraceThread = None

   389

            return True

   390

        return False

   391

   392

    def _Reload(self):

   393

        self.daemon.shutdown(True)

   394

        self.daemon.sock.close()

   395

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

   396

        # never reached

   397

        return 0

   398

   399

    def ForceReload(self):

   400

        # respawn python interpreter

   401

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

   402

        return True

   403

   404

    def GetPLCstatus(self):

   405

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

   406

   407

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

   408

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

   409

            NewFileName = md5sum + lib_ext

   410

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

   411

   412

            self.UnLoadPLC()

   413

   414

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

   415

            self.PLCStatus = "Empty"

   416

   417

            try:

   418

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

   419

                                       self.CurrentPLCFilename))

   420

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

   421

                    try:

   422

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

   423

                    except:

   424

                        pass

   425

            except:

   426

                pass

   427

   428

            try:

   429

                # Create new PLC file

   430

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

   431

                     'wb').write(data)

   432

   433

                # Store new PLC filename based on md5 key

   434

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

   435

   436

                # Then write the files

   437

                log = file(extra_files_log, "w")

   438

                for fname, fdata in extrafiles:

   439

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

   440

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

   441

                    log.write(fname+'\n')

   442

   443

                # Store new PLC filename

   444

                self.CurrentPLCFilename = NewFileName

   445

            except:

   446

                self.PLCStatus = "Broken"

   447

                self.StatusChange()

   448

                PLCprint(traceback.format_exc())

   449

                return False

   450

   451

            if self.LoadPLC():

   452

                self.PLCStatus = "Stopped"

   453

            else:

   454

                self.PLCStatus = "Broken"

   455

                self._FreePLC()

   456

            self.StatusChange()

   457

   458

            return self.PLCStatus == "Stopped"

   459

        return False

   460

   461

    def MatchMD5(self, MD5):

   462

        try:

   463

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

   464

            return last_md5 == MD5

   465

        except:

   466

            pass

   467

        return False

   468

   469

    def SetTraceVariablesList(self, idxs):

   470

        """

   471

        Call ctype imported function to append

   472

        these indexes to registred variables in PLC debugger

   473

        """

   474

        if idxs:

   475

            # suspend but dont disable

   476

            if self._suspendDebug(False) == 0:

   477

                # keep a copy of requested idx

   478

                self._ResetDebugVariables()