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

   159

                self.PythonIteratorLock = Lock()

   160

                self.PythonIteratorLock.acquire()

   161

                def PythonIterator(res, blkid):

   162

                    self.PythonIteratorLock.acquire()

   163

                    self.PythonIteratorLock.release()

   164

                    return None

   165

                self._PythonIterator = PythonIterator

   166

   167

                def __StopPLC():

   168

                    self._stopPLC_real()

   169

                    self.PythonIteratorLock.release()

   170

                self._stopPLC = __StopPLC

   171

   172

   173

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   174

            self._ResetDebugVariables.restype = None

   175

   176

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   177

            self._RegisterDebugVariable.restype = None

   178

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

   179

   180

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   181

            self._FreeDebugData.restype = None

   182

   183

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   184

            self._GetDebugData.restype = ctypes.c_int

   185

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

   186

   187

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   188

            self._suspendDebug.restype = ctypes.c_int

   189

            self._suspendDebug.argtypes = [ctypes.c_int]

   190

   191

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   192

            self._resumeDebug.restype = None

   193

   194

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   195

            self._ResetLogCount.restype = None

   196

   197

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   198

            self._GetLogCount.restype = ctypes.c_uint32

   199

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   200

   201

            self._LogMessage = self.PLClibraryHandle.LogMessage

   202

            self._LogMessage.restype = ctypes.c_int

   203

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

   204

   205

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

   206

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   207

            self._GetLogMessage.restype = ctypes.c_uint32

   208

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

   209

   210

            self._loading_error = None

   211

   212

            self.PythonRuntimeInit()

   213

   214

            return True

   215

        except:

   216

            self._loading_error = traceback.format_exc()

   217

            PLCprint(self._loading_error)

   218

            return False

   219

   220

    def UnLoadPLC(self):

   221

        self.PythonRuntimeCleanup()

   222

        self._FreePLC()

   223

   224

    def _FreePLC(self):

   225

        """

   226

        Unload PLC library.

   227

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

   228

        """

   229

        self.PLClibraryLock.acquire()

   230

        # Forget all refs to library

   231

        self._startPLC = lambda x,y:None

   232

        self._stopPLC = lambda:None

   233

        self._ResetDebugVariables = lambda:None

   234

        self._RegisterDebugVariable = lambda x, y:None

   235

        self._IterDebugData = lambda x,y:None

   236

        self._FreeDebugData = lambda:None

   237

        self._GetDebugData = lambda:-1

   238

        self._suspendDebug = lambda x:-1

   239

        self._resumeDebug = lambda:None

   240

        self._PythonIterator = lambda:""

   241

        self._GetLogCount = None

   242

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

   243

        self._GetLogMessage = None

   244

        self.PLClibraryHandle = None

   245

        # Unload library explicitely

   246

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

   247

            dlclose(self._PLClibraryHandle)

   248

            self._PLClibraryHandle = None

   249

   250

        self.PLClibraryLock.release()

   251

        return False

   252

   253

    def PythonRuntimeCall(self, methodname):

   254

        """

   255

        Calls init, start, stop or cleanup method provided by

   256

        runtime python files, loaded when new PLC uploaded

   257

        """

   258

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

   259

            res,exp = self.evaluator(method)

   260

            if exp is not None:

   261

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

   262

   263

    def PythonRuntimeInit(self):

   264

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

   265

        self.python_runtime_vars = globals().copy()

   266

        self.python_runtime_vars.update(self.pyruntimevars)

   267

   268

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

   269

        for methodname in MethodNames :

   270

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

   271

        self.python_runtime_vars["PLCObject"] = self

   272

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

   273

        class PLCSafeGlobals:

   274

            def __getattr__(_self, name):

   275

                try :

   276

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

   277

                except KeyError:

   278

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

   279

                v = t()

   280

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

   281

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

   282

            def __setattr__(_self, name, value):

   283

                try :

   284

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

   285

                except KeyError:

   286

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

   287

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

   288

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

   289

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

   290

        try:

   291

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

   292

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

   293

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

   294

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

   295

                    for methodname in MethodNames:

   296

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

   297

                        if method is not None:

   298

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

   299

        except:

   300

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

   301

            raise

   302

   303

        self.PythonRuntimeCall("init")

   304

   305

   306

   307

    def PythonRuntimeCleanup(self):

   308

        if self.python_runtime_vars is not None:

   309

            self.PythonRuntimeCall("cleanup")

   310

   311

        self.python_runtime_vars = None

   312

   313

    def PythonThreadProc(self):

   314

        self.PLCStatus = "Started"

   315

        self.StatusChange()

   316

        self.StartSem.release()

   317

        self.PythonRuntimeCall("start")

   318

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

   319

        compile_cache={}

   320

        while True:

   321

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

   322

            cmd = self._PythonIterator(res,blkid)

   323

            FBID = blkid.value

   324

            # print " -> ", cmd, blkid

   325

            if cmd is None:

   326

                break

   327

            try :

   328

                self.python_runtime_vars["FBID"]=FBID

   329

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

   330

                if ccmd is None or ccmd!=cmd:

   331

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

   332

                    compile_cache[FBID]=(cmd,AST)

   333

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

   334

                if exp is not None:

   335

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

   336

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

   337

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

   338

                else:

   339

                    res=str(result)

   340

                self.python_runtime_vars["FBID"]=None

   341

            except Exception,e:

   342

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

   343

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

   344

        self.PLCStatus = "Stopped"

   345

        self.StatusChange()

   346

        self.PythonRuntimeCall("stop")

   347

   348

    def StartPLC(self):

   349

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

   350

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

   351

            error = None

   352

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

   353

            if res == 0:

   354

                self.StartSem=Semaphore(0)

   355

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

   356

                self.PythonThread.start()

   357

                self.StartSem.acquire()

   358

                self.LogMessage("PLC started")

   359

            else:

   360

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

   361

                self.PLCStatus = "Broken"

   362

                self.StatusChange()

   363

   364

    def StopPLC(self):

   365

        if self.PLCStatus == "Started":

   366

            self.LogMessage("PLC stopped")

   367

            self._stopPLC()

   368

            self.PythonThread.join()

   369

            if self.TraceThread is not None :

   370

                self.TraceWakeup.set()

   371

                self.TraceThread.join()

   372

                self.TraceThread = None

   373

            return True

   374

        return False

   375

   376

    def _Reload(self):

   377

        self.daemon.shutdown(True)

   378

        self.daemon.sock.close()

   379

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

   380

        # never reached

   381

        return 0

   382

   383

    def ForceReload(self):

   384

        # respawn python interpreter

   385

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

   386

        return True

   387

   388

    def GetPLCstatus(self):

   389

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

   390

   391

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

   392

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

   393

            NewFileName = md5sum + lib_ext

   394

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

   395

   396

            self.UnLoadPLC()

   397

   398

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

   399

            self.PLCStatus = "Empty"

   400

   401

            try:

   402

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

   403

                                       self.CurrentPLCFilename))

   404

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

   405

                    try:

   406

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

   407

                    except:

   408

                        pass

   409

            except:

   410

                pass

   411

   412

            try:

   413

                # Create new PLC file

   414

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

   415

                     'wb').write(data)

   416

   417

                # Store new PLC filename based on md5 key

   418

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

   419

   420

                # Then write the files

   421

                log = file(extra_files_log, "w")

   422

                for fname,fdata in extrafiles:

   423

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

   424

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

   425

                    log.write(fname+'\n')

   426

   427

                # Store new PLC filename

   428

                self.CurrentPLCFilename = NewFileName

   429

            except:

   430

                self.PLCStatus = "Broken"

   431

                self.StatusChange()

   432

                PLCprint(traceback.format_exc())

   433

                return False

   434

   435

            if self.LoadPLC():

   436

                self.PLCStatus = "Stopped"

   437

            else:

   438

                self.PLCStatus = "Broken"

   439

                self._FreePLC()

   440

            self.StatusChange()

   441

   442

            return self.PLCStatus == "Stopped"

   443

        return False

   444

   445

    def MatchMD5(self, MD5):

   446

        try:

   447

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

   448

            return last_md5 == MD5

   449

        except:

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