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 = "Empty"

    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

    def AutoLoad(self):

    77

        # Get the last transfered PLC if connector must be restart

    78

        try:

    79

            self.CurrentPLCFilename=open(

    80

                             self._GetMD5FileName(),

    81

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

    82

            self.LoadPLC()

    83

        except Exception, e:

    84

            self.PLCStatus = "Empty"

    85

            self.CurrentPLCFilename=None

    86

    87

    def StatusChange(self):

    88

        if self.statuschange is not None:

    89

            for callee in self.statuschange:

    90

                callee(self.PLCStatus)

    91

    92

    def LogMessage(self, *args):

    93

        if len(args) == 2:

    94

            level, msg = args

    95

        else:

    96

            level = LogLevelsDefault

    97

            msg, = args

    98

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

    99

   100

    def ResetLogCount(self):

   101

        if self._ResetLogCount is not None:

   102

            self._ResetLogCount()

   103

   104

    def GetLogCount(self, level):

   105

        if self._GetLogCount is not None :

   106

            return int(self._GetLogCount(level))

   107

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

   108

            return 1

   109

   110

    def GetLogMessage(self, level, msgid):

   111

        tick = ctypes.c_uint32()

   112

        tv_sec = ctypes.c_uint32()

   113

        tv_nsec = ctypes.c_uint32()

   114

        if self._GetLogMessage is not None:

   115

            maxsz = len(self._log_read_buffer)-1

   116

            sz = self._GetLogMessage(level, msgid,

   117

                self._log_read_buffer, maxsz,

   118

                ctypes.byref(tick),

   119

                ctypes.byref(tv_sec),

   120

                ctypes.byref(tv_nsec))

   121

            if sz and sz <= maxsz:

   122

                self._log_read_buffer[sz] = '\x00'

   123

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

   124

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

   125

            return self._loading_error,0,0,0

   126

        return None

   127

   128

    def _GetMD5FileName(self):

   129

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

   130

   131

    def _GetLibFileName(self):

   132

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

   133

   134

   135

    def LoadPLC(self):

   136

        """

   137

        Load PLC library

   138

        Declare all functions, arguments and return values

   139

        """

   140

        try:

   141

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

   142

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

   143

   144

            self._startPLC = self.PLClibraryHandle.startPLC

   145

            self._startPLC.restype = ctypes.c_int

   146

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

   147

   148

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   149

            self._stopPLC_real.restype = None

   150

   151

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

   152

            if self._PythonIterator is not None:

   153

                self._PythonIterator.restype = ctypes.c_char_p

   154

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

   155

   156

                self._stopPLC = self._stopPLC_real

   157

            else:

   158

                # If python confnode is not enabled, we reuse _PythonIterator

   159

                # as a call that block pythonthread until StopPLC

   160

                self.PlcStopping = Event()

   161

                def PythonIterator(res, blkid):

   162

                    self.PlcStopping.clear()

   163

                    self.PlcStopping.wait()

   164

                    return None

   165

                self._PythonIterator = PythonIterator

   166

   167

                def __StopPLC():

   168

                    self._stopPLC_real()

   169

                    self.PlcStopping.set()

   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

        class PLCSafeGlobals:

   269

            def __getattr__(_self, name):

   270

                try :

   271

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

   272

                except KeyError:

   273

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

   274

                v = t()

   275

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

   276

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

   277

            def __setattr__(_self, name, value):

   278

                try :

   279

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

   280

                except KeyError:

   281

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

   282

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

   283

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

   284

   285

        self.python_runtime_vars.update({

   286

            "PLCGlobals" : PLCSafeGlobals(),

   287

            "WorkingDir" : self.workingdir,

   288

            "PLCObject"  : self,

   289

            "PLCBinary"  : self.PLClibraryHandle,

   290

            "PLCGlobalsDesc" : []})

   291

   292

        for methodname in MethodNames :

   293

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

   294

   295

        try:

   296

            filenames = os.listdir(self.workingdir)

   297

            filenames.sort()

   298

            for filename in filenames:

   299

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

   300

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

   301

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

   302

                    for methodname in MethodNames:

   303

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

   304

                        if method is not None:

   305

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

   306

        except:

   307

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

   308

            raise

   309

   310

        self.PythonRuntimeCall("init")

   311

   312

   313

   314

    def PythonRuntimeCleanup(self):

   315

        if self.python_runtime_vars is not None:

   316

            self.PythonRuntimeCall("cleanup")

   317

   318

        self.python_runtime_vars = None

   319

   320

    def PythonThreadProc(self):

   321

        self.StartSem.release()

   322

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

   323

        compile_cache={}

   324

        while True:

   325

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

   326

            cmd = self._PythonIterator(res,blkid)

   327

            FBID = blkid.value

   328

            # print " -> ", cmd, blkid

   329

            if cmd is None:

   330

                break

   331

            try :

   332

                self.python_runtime_vars["FBID"]=FBID

   333

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

   334

                if ccmd is None or ccmd!=cmd:

   335

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

   336

                    compile_cache[FBID]=(cmd,AST)

   337

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

   338

                if exp is not None:

   339

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

   340

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

   341

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

   342

                else:

   343

                    res=str(result)

   344

                self.python_runtime_vars["FBID"]=None

   345

            except Exception,e:

   346

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

   347

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

   348

   349

    def StartPLC(self):

   350

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

   351

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

   352

            error = None

   353

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

   354

            if res == 0:

   355

                self.PLCStatus = "Started"

   356

                self.StatusChange()

   357

                self.PythonRuntimeCall("start")

   358

                self.StartSem=Semaphore(0)

   359

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

   360

                self.PythonThread.start()

   361

                self.StartSem.acquire()

   362

                self.LogMessage("PLC started")

   363

            else:

   364

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

   365

                self.PLCStatus = "Broken"

   366

                self.StatusChange()

   367

   368

    def StopPLC(self):

   369

        if self.PLCStatus == "Started":

   370

            self.LogMessage("PLC stopped")

   371

            self._stopPLC()

   372

            self.PythonThread.join()

   373

            self.PLCStatus = "Stopped"

   374

            self.StatusChange()

   375

            self.PythonRuntimeCall("stop")

   376

            if self.TraceThread is not None :

   377

                self.TraceWakeup.set()

   378

                self.TraceThread.join()

   379

                self.TraceThread = None

   380

            return True

   381

        return False

   382

   383

    def _Reload(self):

   384

        self.daemon.shutdown(True)

   385

        self.daemon.sock.close()

   386

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

   387

        # never reached

   388

        return 0

   389

   390

    def ForceReload(self):

   391

        # respawn python interpreter

   392

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

   393

        return True

   394

   395

    def GetPLCstatus(self):

   396

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

   397

   398

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

   399

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

   400

            NewFileName = md5sum + lib_ext

   401

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

   402

   403

            self.UnLoadPLC()

   404

   405

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

   406

            self.PLCStatus = "Empty"

   407

   408

            try:

   409

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

   410

                                       self.CurrentPLCFilename))

   411

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

   412

                    try:

   413

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

   414

                    except:

   415

                        pass

   416

            except:

   417

                pass

   418

   419

            try:

   420

                # Create new PLC file

   421

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

   422

                     'wb').write(data)

   423

   424

                # Store new PLC filename based on md5 key

   425

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

   426

   427

                # Then write the files

   428

                log = file(extra_files_log, "w")

   429

                for fname,fdata in extrafiles:

   430

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

   431

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

   432

                    log.write(fname+'\n')

   433

   434

                # Store new PLC filename

   435

                self.CurrentPLCFilename = NewFileName

   436

            except:

   437

                self.PLCStatus = "Broken"

   438

                self.StatusChange()

   439

                PLCprint(traceback.format_exc())

   440

                return False

   441

   442

            if self.LoadPLC():

   443

                self.PLCStatus = "Stopped"

   444

            else:

   445

                self.PLCStatus = "Broken"

   446

                self._FreePLC()

   447

            self.StatusChange()

   448

   449

            return self.PLCStatus == "Stopped"

   450

        return False

   451

   452

    def MatchMD5(self, MD5):

   453

        try:

   454

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

   455

            return last_md5 == MD5

   456

        except:

   457

            pass

   458

        return False

   459

   460

    def SetTraceVariablesList(self, idxs):

   461

        """

   462

        Call ctype imported function to append

   463

        these indexes to registred variables in PLC debugger

   464

        """

   465

        if idxs:

   466

            # suspend but dont disable

   467

            if self._suspendDebug(False) == 0:

   468

                # keep a copy of requested idx

   469

                self._ResetDebugVariables()

   470

                for idx,iectype,force in idxs:

   471

                    if force !=None:

   472

                        c_type,unpack_func, pack_func = \

   473

                            TypeTranslator.get(iectype,

   474

                                                    (None,None,None))

   475

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

   476

                    self._RegisterDebugVariable(idx, force)

   477

                self._TracesSwap()

   478

                self._resumeDebug()

   479

        else:

   480

            self._suspendDebug(True)

   481