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

    50

lib_ext = {

    51

     "linux2": ".so",

    52

     "win32":  ".dll",

    53

     }.get(sys.platform, "")

    54

    55

    56

def PLCprint(message):

    57

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

    58

    sys.stdout.flush()

    59

    60

    61

class PLCObject(pyro.ObjBase):

    62

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

    63

        pyro.ObjBase.__init__(self)

    64

        self.evaluator = evaluator

    65

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

    66

        self.workingdir = workingdir

    67

        self.PLCStatus = "Empty"

    68

        self.PLClibraryHandle = None

    69

        self.PLClibraryLock = Lock()

    70

        self.DummyIteratorLock = None

    71

        # Creates fake C funcs proxies

    72

        self._FreePLC()

    73

        self.daemon = daemon

    74

        self.statuschange = statuschange

    75

        self.hmi_frame = None

    76

        self.pyruntimevars = pyruntimevars

    77

        self._loading_error = None

    78

        self.python_runtime_vars = None

    79

        self.TraceThread = None

    80

        self.TraceLock = Lock()

    81

        self.TraceWakeup = Event()

    82

        self.Traces = []

    83

    84

    def AutoLoad(self):

    85

        # Get the last transfered PLC if connector must be restart

    86

        try:

    87

            self.CurrentPLCFilename = open(

    88

                             self._GetMD5FileName(),

    89

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

    90

            if self.LoadPLC():

    91

                self.PLCStatus = "Stopped"

    92

        except Exception, e:

    93

            self.PLCStatus = "Empty"

    94

            self.CurrentPLCFilename = None

    95

    96

    def StatusChange(self):

    97

        if self.statuschange is not None:

    98

            for callee in self.statuschange:

    99

                callee(self.PLCStatus)

   100

   101

    def LogMessage(self, *args):

   102

        if len(args) == 2:

   103

            level, msg = args

   104

        else:

   105

            level = LogLevelsDefault

   106

            msg, = args

   107

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

   108

   109

    def ResetLogCount(self):

   110

        if self._ResetLogCount is not None:

   111

            self._ResetLogCount()

   112

   113

    def GetLogCount(self, level):

   114

        if self._GetLogCount is not None:

   115

            return int(self._GetLogCount(level))

   116

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

   117

            return 1

   118

   119

    def GetLogMessage(self, level, msgid):

   120

        tick = ctypes.c_uint32()

   121

        tv_sec = ctypes.c_uint32()

   122

        tv_nsec = ctypes.c_uint32()

   123

        if self._GetLogMessage is not None:

   124

            maxsz = len(self._log_read_buffer)-1

   125

            sz = self._GetLogMessage(level, msgid,

   126

                self._log_read_buffer, maxsz,

   127

                ctypes.byref(tick),

   128

                ctypes.byref(tv_sec),

   129

                ctypes.byref(tv_nsec))

   130

            if sz and sz <= maxsz:

   131

                self._log_read_buffer[sz] = '\x00'

   132

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

   133

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

   134

            return self._loading_error, 0, 0, 0

   135

        return None

   136

   137

    def _GetMD5FileName(self):

   138

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

   139

   140

    def _GetLibFileName(self):

   141

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

   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

   175

                def PythonIterator(res, blkid):

   176

                    self.PlcStopping.clear()

   177

                    self.PlcStopping.wait()

   178

                    return None

   179

                self._PythonIterator = PythonIterator

   180

   181

                def __StopPLC():

   182

                    self._stopPLC_real()

   183

                    self.PlcStopping.set()

   184

                self._stopPLC = __StopPLC

   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

   218

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

   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

   291

            def __setattr__(_self, name, value):

   292

                try:

   293

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

   294

                except KeyError:

   295

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

   296

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

   297

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

   298

   299

        self.python_runtime_vars.update({

   300

            "PLCGlobals":     PLCSafeGlobals(),

   301

            "WorkingDir":     self.workingdir,

   302

            "PLCObject":      self,

   303

            "PLCBinary":      self.PLClibraryHandle,

   304

            "PLCGlobalsDesc": []})

   305

   306

        for methodname in MethodNames:

   307

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

   308

   309

        try:

   310

            filenames = os.listdir(self.workingdir)

   311

            filenames.sort()

   312

            for filename in filenames:

   313

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

   314

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

   315

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

   316

                    for methodname in MethodNames:

   317

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

   318

                        if method is not None:

   319

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

   320

        except:

   321

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

   322

            raise

   323

   324

        self.PythonRuntimeCall("init")

   325

   326

    def PythonRuntimeCleanup(self):

   327

        if self.python_runtime_vars is not None:

   328

            self.PythonRuntimeCall("cleanup")

   329

   330

        self.python_runtime_vars = None

   331

   332

    def PythonThreadProc(self):

   333

        self.StartSem.release()

   334

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

   335

        compile_cache = {}

   336

        while True:

   337

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

   338

            cmd = self._PythonIterator(res, blkid)

   339

            FBID = blkid.value

   340

            # print " -> ", cmd, blkid

   341

            if cmd is None:

   342

                break

   343

            try:

   344

                self.python_runtime_vars["FBID"] = FBID

   345

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

   346

                if ccmd is None or ccmd != cmd:

   347

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

   348

                    compile_cache[FBID] = (cmd, AST)

   349

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

   350

                if exp is not None:

   351

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

   352

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

   353

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

   354

                else:

   355

                    res = str(result)

   356

                self.python_runtime_vars["FBID"] = None

   357

            except Exception, e:

   358

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

   359

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

   360

   361

    def StartPLC(self):

   362

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

   363

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

   364

            error = None

   365

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

   366

            if res == 0:

   367

                self.PLCStatus = "Started"

   368

                self.StatusChange()

   369

                self.PythonRuntimeCall("start")

   370

                self.StartSem = Semaphore(0)

   371

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

   372

                self.PythonThread.start()

   373

                self.StartSem.acquire()

   374

                self.LogMessage("PLC started")

   375

            else:

   376

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

   377

                self.PLCStatus = "Broken"

   378

                self.StatusChange()

   379

   380

    def StopPLC(self):

   381

        if self.PLCStatus == "Started":

   382

            self.LogMessage("PLC stopped")

   383

            self._stopPLC()

   384

            self.PythonThread.join()

   385

            self.PLCStatus = "Stopped"

   386

            self.StatusChange()

   387

            self.PythonRuntimeCall("stop")

   388

            if self.TraceThread is not None:

   389

                self.TraceWakeup.set()

   390

                self.TraceThread.join()

   391

                self.TraceThread = None

   392

            return True

   393

        return False

   394

   395

    def _Reload(self):

   396

        self.daemon.shutdown(True)

   397

        self.daemon.sock.close()

   398

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

   399

        # never reached

   400

        return 0

   401

   402

    def ForceReload(self):

   403

        # respawn python interpreter

   404

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

   405

        return True

   406

   407

    def GetPLCstatus(self):

   408

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

   409

   410

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

   411

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

   412

            NewFileName = md5sum + lib_ext

   413

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

   414

   415

            self.UnLoadPLC()

   416

   417

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

   418

            self.PLCStatus = "Empty"

   419

   420

            try:

   421

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

   422

                                       self.CurrentPLCFilename))

   423

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

   424

                    try:

   425

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

   426

                    except:

   427

                        pass

   428

            except:

   429

                pass

   430

   431

            try:

   432

                # Create new PLC file

   433

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

   434

                     'wb').write(data)

   435

   436

                # Store new PLC filename based on md5 key

   437

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

   438

   439

                # Then write the files

   440

                log = file(extra_files_log, "w")

   441

                for fname, fdata in extrafiles:

   442

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

   443

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

   444

                    log.write(fname+'\n')

   445

   446

                # Store new PLC filename

   447

                self.CurrentPLCFilename = NewFileName

   448

            except:

   449

                self.PLCStatus = "Broken"

   450

                self.StatusChange()

   451

                PLCprint(traceback.format_exc())

   452

                return False

   453

   454

            if self.LoadPLC():

   455

                self.PLCStatus = "Stopped"

   456

            else:

   457

                self.PLCStatus = "Broken"

   458

                self._FreePLC()

   459

            self.StatusChange()

   460

   461

            return self.PLCStatus == "Stopped"

   462

        return False

   463

   464

    def MatchMD5(self, MD5):

   465

        try:

   466

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

   467

            return last_md5 == MD5

   468

        except:

   469

            pass

   470

        return False

   471

   472

    def SetTraceVariablesList(self, idxs):

   473

        """

   474

        Call ctype imported function to append

   475

        these indexes to registred variables in PLC debugger

   476

        """

   477

        if idxs:

   478

            # suspend but dont disable