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, Event

    27

import ctypes, os, commands, types, sys

    28

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

    29

from time import time

    30

    31

    32

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

    33

    from _ctypes import LoadLibrary as dlopen

    34

    from _ctypes import FreeLibrary as dlclose

    35

elif os.name == "posix":

    36

    from _ctypes import dlopen, dlclose

    37

    38

import traceback

    39

def get_last_traceback(tb):

    40

    while tb.tb_next:

    41

        tb = tb.tb_next

    42

    return tb

    43

    44

lib_ext ={

    45

     "linux2":".so",

    46

     "win32":".dll",

    47

     }.get(sys.platform, "")

    48

    49

def PLCprint(message):

    50

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

    51

    sys.stdout.flush()

    52

    53

class PLCObject(pyro.ObjBase):

    54

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

    55

        pyro.ObjBase.__init__(self)

    56

        self.evaluator = evaluator

    57

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

    58

        self.workingdir = workingdir

    59

        self.PLCStatus = "Stopped"

    60

        self.PLClibraryHandle = None

    61

        self.PLClibraryLock = Lock()

    62

        self.DummyIteratorLock = None

    63

        # Creates fake C funcs proxies

    64

        self._FreePLC()

    65

        self.daemon = daemon

    66

        self.statuschange = statuschange

    67

        self.hmi_frame = None

    68

        self.pyruntimevars = pyruntimevars

    69

        self._loading_error = None

    70

        self.python_runtime_vars = None

    71

        self.TraceThread = None

    72

        self.TraceLock = Lock()

    73

        self.TraceWakeup = Event()

    74

        self.Traces = []

    75

    76

        # Get the last transfered PLC if connector must be restart

    77

        try:

    78

            self.CurrentPLCFilename=open(

    79

                             self._GetMD5FileName(),

    80

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

    81

            self.LoadPLC()

    82

        except Exception, e:

    83

            self.PLCStatus = "Empty"

    84

            self.CurrentPLCFilename=None

    85

    86

    def StatusChange(self):

    87

        if self.statuschange is not None:

    88

            for callee in self.statuschange:

    89

                callee(self.PLCStatus)

    90

    91

    def LogMessage(self, *args):

    92

        if len(args) == 2:

    93

            level, msg = args

    94

        else:

    95

            level = LogLevelsDefault

    96

            msg, = args

    97

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

    98

    99

    def ResetLogCount(self):

   100

        if self._ResetLogCount is not None:

   101

            self._ResetLogCount()

   102

   103

    def GetLogCount(self, level):

   104

        if self._GetLogCount is not None :

   105

            return int(self._GetLogCount(level))

   106

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

   107

            return 1

   108

   109

    def GetLogMessage(self, level, msgid):

   110

        tick = ctypes.c_uint32()

   111

        tv_sec = ctypes.c_uint32()

   112

        tv_nsec = ctypes.c_uint32()

   113

        if self._GetLogMessage is not None:

   114

            maxsz = len(self._log_read_buffer)-1

   115

            sz = self._GetLogMessage(level, msgid,

   116

                self._log_read_buffer, maxsz,

   117

                ctypes.byref(tick),

   118

                ctypes.byref(tv_sec),

   119

                ctypes.byref(tv_nsec))

   120

            if sz and sz <= maxsz:

   121

                self._log_read_buffer[sz] = '\x00'

   122

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

   123

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

   124

            return self._loading_error,0,0,0

   125

        return None

   126

   127

    def _GetMD5FileName(self):

   128

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

   129

   130

    def _GetLibFileName(self):

   131

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

   132

   133

   134

    def LoadPLC(self):

   135

        """

   136

        Load PLC library

   137

        Declare all functions, arguments and return values

   138

        """

   139

        try:

   140

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

   141

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

   142

   143

            self._startPLC = self.PLClibraryHandle.startPLC

   144

            self._startPLC.restype = ctypes.c_int

   145

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

   146

   147

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   148

            self._stopPLC_real.restype = None

   149

   150

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

   151

            if self._PythonIterator is not None:

   152

                self._PythonIterator.restype = ctypes.c_char_p

   153

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

   154

   155

                self._stopPLC = self._stopPLC_real

   156

            else:

   157

                # If python confnode is not enabled, we reuse _PythonIterator

   158

                # as a call that block pythonthread until StopPLC

   160

                def PythonIterator(res, blkid):

   163

                    return None

   164

                self._PythonIterator = PythonIterator

   165

   166

                def __StopPLC():

   167

                    self._stopPLC_real()

   169

                self._stopPLC = __StopPLC

   170

   171

   172

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   173

            self._ResetDebugVariables.restype = None

   174

   175

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   176

            self._RegisterDebugVariable.restype = None

   177

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

   178

   179

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   180

            self._FreeDebugData.restype = None

   181

   182

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   183

            self._GetDebugData.restype = ctypes.c_int

   184

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

   185

   186

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   187

            self._suspendDebug.restype = ctypes.c_int

   188

            self._suspendDebug.argtypes = [ctypes.c_int]

   189

   190

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   191

            self._resumeDebug.restype = None

   192

   193

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   194

            self._ResetLogCount.restype = None

   195

   196

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   197

            self._GetLogCount.restype = ctypes.c_uint32

   198

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   199

   200

            self._LogMessage = self.PLClibraryHandle.LogMessage

   201

            self._LogMessage.restype = ctypes.c_int

   202

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

   203

   204

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

   205

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   206

            self._GetLogMessage.restype = ctypes.c_uint32

   207

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

   208

   209

            self._loading_error = None

   210

   211

            self.PythonRuntimeInit()

   212

   213

            return True

   214

        except:

   215

            self._loading_error = traceback.format_exc()

   216

            PLCprint(self._loading_error)

   217

            return False

   218

   219

    def UnLoadPLC(self):

   220

        self.PythonRuntimeCleanup()

   221

        self._FreePLC()

   222

   223

    def _FreePLC(self):

   224

        """

   225

        Unload PLC library.

   226

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

   227

        """

   228

        self.PLClibraryLock.acquire()

   229

        # Forget all refs to library

   230

        self._startPLC = lambda x,y:None

   231

        self._stopPLC = lambda:None

   232

        self._ResetDebugVariables = lambda:None

   233

        self._RegisterDebugVariable = lambda x, y:None

   234

        self._IterDebugData = lambda x,y:None

   235

        self._FreeDebugData = lambda:None

   236

        self._GetDebugData = lambda:-1

   237

        self._suspendDebug = lambda x:-1

   238

        self._resumeDebug = lambda:None

   239

        self._PythonIterator = lambda:""

   240

        self._GetLogCount = None

   241

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

   242

        self._GetLogMessage = None

   243

        self.PLClibraryHandle = None

   244

        # Unload library explicitely

   245

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

   246

            dlclose(self._PLClibraryHandle)

   247

            self._PLClibraryHandle = None

   248

   249

        self.PLClibraryLock.release()

   250

        return False

   251

   252

    def PythonRuntimeCall(self, methodname):

   253

        """

   254

        Calls init, start, stop or cleanup method provided by

   255

        runtime python files, loaded when new PLC uploaded

   256

        """

   257

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

   258

            res,exp = self.evaluator(method)

   259

            if exp is not None:

   260

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

   261

   262

    def PythonRuntimeInit(self):

   263

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

   264

        self.python_runtime_vars = globals().copy()

   265

        self.python_runtime_vars.update(self.pyruntimevars)

   266

   267

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

   268

        for methodname in MethodNames :

   269

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

   270

        self.python_runtime_vars["PLCObject"] = self

   271

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

   272

        class PLCSafeGlobals:

   273

            def __getattr__(_self, name):

   274

                try :

   275

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

   276

                except KeyError:

   277

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

   278

                v = t()

   279

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

   280

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

   281

            def __setattr__(_self, name, value):

   282

                try :

   283

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

   284

                except KeyError:

   285

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

   286

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

   287

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

   288

        self.python_runtime_vars["PLCGlobals"] = PLCSafeGlobals()

   289

        try:

   290

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

   291

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

   292

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

   293

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

   294

                    for methodname in MethodNames:

   295

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

   296

                        if method is not None:

   297

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

   298

        except:

   299

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

   300

            raise

   301

   302

        self.PythonRuntimeCall("init")

   303

   304

   305

   306

    def PythonRuntimeCleanup(self):

   307

        if self.python_runtime_vars is not None:

   308

            self.PythonRuntimeCall("cleanup")

   309

   310

        self.python_runtime_vars = None

   311

   312

    def PythonThreadProc(self):

   313

        self.StartSem.release()

   314

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

   315

        compile_cache={}

   316

        while True:

   317

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

   318

            cmd = self._PythonIterator(res,blkid)

   319

            FBID = blkid.value

   320

            # print " -> ", cmd, blkid

   321

            if cmd is None:

   322

                break

   323

            try :

   324

                self.python_runtime_vars["FBID"]=FBID

   325

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

   326

                if ccmd is None or ccmd!=cmd:

   327

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

   328

                    compile_cache[FBID]=(cmd,AST)

   329

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

   330

                if exp is not None:

   331

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

   332

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

   333

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

   334

                else:

   335

                    res=str(result)

   336

                self.python_runtime_vars["FBID"]=None

   337

            except Exception,e:

   338

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

   339

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

   340

   341

    def StartPLC(self):

   342

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

   343

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

   344

            error = None

   345

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

   346

            if res == 0:

   350

                self.StartSem=Semaphore(0)

   351

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

   352

                self.PythonThread.start()

   353

                self.StartSem.acquire()

   354

                self.LogMessage("PLC started")

   355

            else:

   356

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

   357

                self.PLCStatus = "Broken"

   358

                self.StatusChange()

   359

   360

    def StopPLC(self):

   361

        if self.PLCStatus == "Started":

   362

            self.LogMessage("PLC stopped")

   363

            self._stopPLC()

   364

            self.PythonThread.join()

   368

            if self.TraceThread is not None :

   369

                self.TraceWakeup.set()

   370

                self.TraceThread.join()

   371

                self.TraceThread = None

   372

            return True

   373

        return False

   374

   375

    def _Reload(self):

   376

        self.daemon.shutdown(True)

   377

        self.daemon.sock.close()

   378

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

   379

        # never reached

   380

        return 0

   381

   382

    def ForceReload(self):

   383

        # respawn python interpreter

   384

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

   385

        return True

   386

   387

    def GetPLCstatus(self):

   388

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

   389

   390

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

   391

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

   392

            NewFileName = md5sum + lib_ext

   393

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

   394

   395

            self.UnLoadPLC()

   396

   397

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

   398

            self.PLCStatus = "Empty"

   399

   400

            try:

   401

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

   402

                                       self.CurrentPLCFilename))

   403

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

   404

                    try:

   405

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

   406

                    except:

   407

                        pass

   408

            except:

   409

                pass

   410

   411

            try:

   412

                # Create new PLC file

   413

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

   414

                     'wb').write(data)

   415

   416

                # Store new PLC filename based on md5 key

   417

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

   418

   419

                # Then write the files

   420

                log = file(extra_files_log, "w")

   421

                for fname,fdata in extrafiles:

   422

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

   423

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

   424

                    log.write(fname+'\n')

   425

   426

                # Store new PLC filename

   427

                self.CurrentPLCFilename = NewFileName

   428

            except:

   429

                self.PLCStatus = "Broken"

   430

                self.StatusChange()

   431

                PLCprint(traceback.format_exc())

   432

                return False

   433

   434

            if self.LoadPLC():

   435

                self.PLCStatus = "Stopped"

   436

            else:

   437

                self.PLCStatus = "Broken"

   438

                self._FreePLC()

   439

            self.StatusChange()

   440

   441

            return self.PLCStatus == "Stopped"

   442

        return False

   443

   444

    def MatchMD5(self, MD5):

   445

        try:

   446

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

   447

            return last_md5 == MD5

   448

        except:

   449

            pass

   450

        return False

   451

   452

    def SetTraceVariablesList(self, idxs):

   453

        """

   454

        Call ctype imported function to append

   455

        these indexes to registred variables in PLC debugger

   456

        """

   457

        if idxs:

   458

            # suspend but dont disable

   459

            if self._suspendDebug(False) == 0:

   460

                # keep a copy of requested idx

   461

                self._ResetDebugVariables()

   462

                for idx,iectype,force in idxs:

   463

                    if force !=None:

   464

                        c_type,unpack_func, pack_func = \

   465

                            TypeTranslator.get(iectype,

   466

                                                    (None,None,None))

   467

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

   468

                    self._RegisterDebugVariable(idx, force)

   469

                self._TracesSwap()

   470

                self._resumeDebug()

   471

        else:

   472

            self._suspendDebug(True)

   473

   474

    def _TracesPush(self, trace):

   475

        self.TraceLock.acquire()

   476

        lT = len(self.Traces)

   477

        if lT != 0 and lT * len(self.Traces[0]) > 1024 * 1024 :

   478

            self.Traces.pop(0)

   479

        self.Traces.append(trace)

   480

        self.TraceLock.release()

   481

   482

    def _TracesSwap(self):