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

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

   141

        try:

   142

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

   143

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

   144

   145

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

   146

            if len(md5) == 32 : 

   147

                self.PLC_ID.value = md5 

   148

   149

            self._startPLC = self.PLClibraryHandle.startPLC

   150

            self._startPLC.restype = ctypes.c_int

   151

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

   152

   153

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   154

            self._stopPLC_real.restype = None

   155

   156

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

   157

            if self._PythonIterator is not None:

   158

                self._PythonIterator.restype = ctypes.c_char_p

   159

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

   160

   161

                self._stopPLC = self._stopPLC_real

   162

            else:

   163

                # If python confnode is not enabled, we reuse _PythonIterator

   164

                # as a call that block pythonthread until StopPLC

   165

                self.PlcStopping = Event()

   166

                def PythonIterator(res, blkid):

   167

                    self.PlcStopping.clear()

   168

                    self.PlcStopping.wait()

   169

                    return None

   170

                self._PythonIterator = PythonIterator

   171

   172

                def __StopPLC():

   173

                    self._stopPLC_real()

   174

                    self.PlcStopping.set()

   175

                self._stopPLC = __StopPLC

   176

   177

   178

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   179

            self._ResetDebugVariables.restype = None

   180

   181

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   182

            self._RegisterDebugVariable.restype = None

   183

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

   184

   185

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   186

            self._FreeDebugData.restype = None

   187

   188

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   189

            self._GetDebugData.restype = ctypes.c_int

   190

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

   191

   192

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   193

            self._suspendDebug.restype = ctypes.c_int

   194

            self._suspendDebug.argtypes = [ctypes.c_int]

   195

   196

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   197

            self._resumeDebug.restype = None

   198

   199

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   200

            self._ResetLogCount.restype = None

   201

   202

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   203

            self._GetLogCount.restype = ctypes.c_uint32

   204

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   205

   206

            self._LogMessage = self.PLClibraryHandle.LogMessage

   207

            self._LogMessage.restype = ctypes.c_int

   208

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

   209

   210

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

   211

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   212

            self._GetLogMessage.restype = ctypes.c_uint32

   213

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

   214

   215

            self._loading_error = None

   216

   217

            self.PythonRuntimeInit()

   218

   219

            return True

   220

        except:

   221

            self._loading_error = traceback.format_exc()

   222

            PLCprint(self._loading_error)

   223

            return False

   224

   225

    def UnLoadPLC(self):

   226

        self.PythonRuntimeCleanup()

   227

        self._FreePLC()

   228

   229

    def _FreePLC(self):

   230

        """

   231

        Unload PLC library.

   232

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

   233

        """

   234

        self.PLClibraryLock.acquire()

   235

        # Forget all refs to library

   236

        self._startPLC = lambda x,y:None

   237

        self._stopPLC = lambda:None

   238

        self._ResetDebugVariables = lambda:None

   239

        self._RegisterDebugVariable = lambda x, y:None

   240

        self._IterDebugData = lambda x,y:None

   241

        self._FreeDebugData = lambda:None

   242

        self._GetDebugData = lambda:-1

   243

        self._suspendDebug = lambda x:-1

   244

        self._resumeDebug = lambda:None

   245

        self._PythonIterator = lambda:""

   246

        self._GetLogCount = None

   247

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

   248

        self._GetLogMessage = None

   249

        self.PLClibraryHandle = None

   250

        # Unload library explicitely

   251

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

   252

            dlclose(self._PLClibraryHandle)

   253

            self._PLClibraryHandle = None

   254

   255

        self.PLClibraryLock.release()

   256

        return False

   257

   258

    def PythonRuntimeCall(self, methodname):

   259

        """

   260

        Calls init, start, stop or cleanup method provided by

   261

        runtime python files, loaded when new PLC uploaded

   262

        """

   263

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

   264

            res,exp = self.evaluator(method)

   265

            if exp is not None:

   266

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

   267

   268

    def PythonRuntimeInit(self):

   269

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

   270

        self.python_runtime_vars = globals().copy()

   271

        self.python_runtime_vars.update(self.pyruntimevars)

   272

   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

   290

        self.python_runtime_vars.update({

   291

            "PLCGlobals" : PLCSafeGlobals(),

   292

            "WorkingDir" : self.workingdir,

   293

            "PLCObject"  : self,

   294

            "PLCBinary"  : self.PLClibraryHandle,

   295

            "PLCGlobalsDesc" : []})

   296

   297

        for methodname in MethodNames :

   298

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

   299

   300

        try:

   301

            filenames = os.listdir(self.workingdir)

   302

            filenames.sort()

   303

            for filename in filenames:

   304

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

   305

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

   306

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

   307

                    for methodname in MethodNames:

   308

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

   309

                        if method is not None:

   310

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

   311

        except:

   312

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

   313

            raise

   314

   315

        self.PythonRuntimeCall("init")

   316

   317

   318

   319

    def PythonRuntimeCleanup(self):

   320

        if self.python_runtime_vars is not None:

   321

            self.PythonRuntimeCall("cleanup")

   322

   323

        self.python_runtime_vars = None

   324

   325

    def PythonThreadProc(self):

   326

        self.StartSem.release()

   327

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

   328

        compile_cache={}

   329

        while True:

   330

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

   331

            cmd = self._PythonIterator(res,blkid)

   332

            FBID = blkid.value

   333

            # print " -> ", cmd, blkid

   334

            if cmd is None:

   335

                break

   336

            try :

   337

                self.python_runtime_vars["FBID"]=FBID

   338

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

   339

                if ccmd is None or ccmd!=cmd:

   340

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

   341

                    compile_cache[FBID]=(cmd,AST)

   342

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

   343

                if exp is not None:

   344

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

   345

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

   346

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

   347

                else:

   348

                    res=str(result)

   349

                self.python_runtime_vars["FBID"]=None

   350

            except Exception,e:

   351

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

   352

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

   353

   354

    def StartPLC(self):

   355

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

   356

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

   357

            error = None

   358

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

   359

            if res == 0:

   360

                self.PLCStatus = "Started"

   361

                self.StatusChange()

   362

                self.PythonRuntimeCall("start")

   363

                self.StartSem=Semaphore(0)

   364

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

   365

                self.PythonThread.start()

   366

                self.StartSem.acquire()

   367

                self.LogMessage("PLC started")

   368

            else:

   369

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

   370

                self.PLCStatus = "Broken"

   371

                self.StatusChange()

   372

   373

    def StopPLC(self):

   374

        if self.PLCStatus == "Started":

   375

            self.LogMessage("PLC stopped")

   376

            self._stopPLC()

   377

            self.PythonThread.join()

   378

            self.PLCStatus = "Stopped"

   379

            self.StatusChange()

   380

            self.PythonRuntimeCall("stop")

   381

            if self.TraceThread is not None :

   382

                self.TraceWakeup.set()

   383

                self.TraceThread.join()

   384

                self.TraceThread = None

   385

            return True

   386

        return False

   387

   388

    def _Reload(self):

   389

        self.daemon.shutdown(True)

   390

        self.daemon.sock.close()

   391

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

   392

        # never reached

   393

        return 0

   394

   395

    def ForceReload(self):

   396

        # respawn python interpreter

   397

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

   398

        return True

   399

   400

    def GetPLCstatus(self):

   401

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

   402

   403

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

   404

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

   405

            NewFileName = md5sum + lib_ext

   406

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

   407

   408

            self.UnLoadPLC()

   409

   410

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

   411

            self.PLCStatus = "Empty"

   412

   413

            try:

   414

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

   415

                                       self.CurrentPLCFilename))

   416

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

   417

                    try:

   418

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

   419

                    except:

   420

                        pass

   421

            except:

   422

                pass

   423

   424

            try:

   425

                # Create new PLC file

   426

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

   427

                     'wb').write(data)

   428

   429

                # Store new PLC filename based on md5 key

   430

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

   431

   432

                # Then write the files

   433

                log = file(extra_files_log, "w")

   434

                for fname,fdata in extrafiles:

   435

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

   436

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

   437

                    log.write(fname+'\n')

   438

   439

                # Store new PLC filename

   440

                self.CurrentPLCFilename = NewFileName

   441

            except:

   442

                self.PLCStatus = "Broken"

   443

                self.StatusChange()

   444

                PLCprint(traceback.format_exc())

   445

                return False

   446

   447

            if self.LoadPLC():

   448

                self.PLCStatus = "Stopped"

   449

            else:

   450

                self.PLCStatus = "Broken"

   451

                self._FreePLC()

   452

            self.StatusChange()

   453

   454

            return self.PLCStatus == "Stopped"

   455

        return False

   456

   457

    def MatchMD5(self, MD5):

   458

        try:

   459

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

   460

            return last_md5 == MD5

   461

        except:

   462

            pass

   463

        return False

   464

   465

    def SetTraceVariablesList(self, idxs):

   466

        """

   467

        Call ctype imported function to append

   468

        these indexes to registred variables in PLC debugger

   469

        """

   470

        if idxs:

   471

            # suspend but dont disable

   472

            if self._suspendDebug(False) == 0:

   473

                # keep a copy of requested idx

   474

                self._ResetDebugVariables()

   475

                for idx,iectype,force in idxs:

   476

                    if force !=None:

   477

                        c_type,unpack_func, pack_func = \

   478

                            TypeTranslator.get(iectype,

   479

                                                    (None,None,None))

   480

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

   481

                    self._RegisterDebugVariable(idx, force)