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

    27

import ctypes, os, commands, types, sys

    28

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

    29

    30

    31

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

    32

    from _ctypes import LoadLibrary as dlopen

    33

    from _ctypes import FreeLibrary as dlclose

    34

elif os.name == "posix":

    35

    from _ctypes import dlopen, dlclose

    36

    37

import traceback

    38

def get_last_traceback(tb):

    39

    while tb.tb_next:

    40

        tb = tb.tb_next

    41

    return tb

    42

    43

lib_ext ={

    44

     "linux2":".so",

    45

     "win32":".dll",

    46

     }.get(sys.platform, "")

    47

    48

def PLCprint(message):

    49

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

    50

    sys.stdout.flush()

    51

    52

class PLCObject(pyro.ObjBase):

    53

    _Idxs = []

    54

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

    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.website = website

    69

        self._loading_error = None

    70

        self.python_runtime_vars = None

    71

    72

        # Get the last transfered PLC if connector must be restart

    73

        try:

    74

            self.CurrentPLCFilename=open(

    75

                             self._GetMD5FileName(),

    76

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

    77

            self.LoadPLC()

    78

        except Exception, e:

    79

            self.PLCStatus = "Empty"

    80

            self.CurrentPLCFilename=None

    81

    82

    def StatusChange(self):

    83

        if self.statuschange is not None:

    84

            self.statuschange(self.PLCStatus)

    85

    86

    def LogMessage(self, *args):

    87

        if len(args) == 2:

    88

            level, msg = args

    89

        else:

    90

            level = LogLevelsDefault

    91

            msg, = args

    92

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

    93

    94

    def ResetLogCount(self):

    95

        if self._ResetLogCount is not None:

    96

            self._ResetLogCount()

    97

    98

    def GetLogCount(self, level):

    99

        if self._GetLogCount is not None :

   100

            return int(self._GetLogCount(level))

   101

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

   102

            return 1

   103

   104

    def GetLogMessage(self, level, msgid):

   105

        tick = ctypes.c_uint32()

   106

        tv_sec = ctypes.c_uint32()

   107

        tv_nsec = ctypes.c_uint32()

   108

        if self._GetLogMessage is not None:

   109

            maxsz = len(self._log_read_buffer)-1

   110

            sz = self._GetLogMessage(level, msgid, 

   111

                self._log_read_buffer, maxsz,

   112

                ctypes.byref(tick),

   113

                ctypes.byref(tv_sec),

   114

                ctypes.byref(tv_nsec))

   115

            if sz and sz <= maxsz:

   116

                self._log_read_buffer[sz] = '\x00'

   117

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

   118

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

   119

            return self._loading_error,0,0,0

   120

        return None

   121

   122

    def _GetMD5FileName(self):

   123

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

   124

   125

    def _GetLibFileName(self):

   126

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

   127

   128

   129

    def LoadPLC(self):

   130

        """

   131

        Load PLC library

   132

        Declare all functions, arguments and return values

   133

        """

   134

        try:

   135

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

   136

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

   137

   138

            self._startPLC = self.PLClibraryHandle.startPLC

   139

            self._startPLC.restype = ctypes.c_int

   140

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

   141

   142

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   143

            self._stopPLC_real.restype = None

   144

   145

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

   146

            if self._PythonIterator is not None:

   147

                self._PythonIterator.restype = ctypes.c_char_p

   148

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

   149

   150

                self._stopPLC = self._stopPLC_real

   151

            else:

   152

                # If python confnode is not enabled, we reuse _PythonIterator

   153

                # as a call that block pythonthread until StopPLC 

   154

                self.PythonIteratorLock = Lock()

   155

                self.PythonIteratorLock.acquire()

   156

                def PythonIterator(res, blkid):

   157

                    self.PythonIteratorLock.acquire()

   158

                    self.PythonIteratorLock.release()

   159

                    return None

   160

                self._PythonIterator = PythonIterator

   161

   162

                def __StopPLC():

   163

                    self._stopPLC_real()

   164

                    self.PythonIteratorLock.release()

   165

                self._stopPLC = __StopPLC

   166

   167

   168

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   169

            self._ResetDebugVariables.restype = None

   170

   171

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   172

            self._RegisterDebugVariable.restype = None

   173

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

   174

   175

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   176

            self._FreeDebugData.restype = None

   177

   178

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   179

            self._GetDebugData.restype = ctypes.c_int  

   180

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

   181

   182

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   183

            self._suspendDebug.restype = ctypes.c_int

   184

            self._suspendDebug.argtypes = [ctypes.c_int]

   185

   186

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   187

            self._resumeDebug.restype = None

   188

   189

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   190

            self._ResetLogCount.restype = None

   191

   192

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   193

            self._GetLogCount.restype = ctypes.c_uint32

   194

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   195

   196

            self._LogMessage = self.PLClibraryHandle.LogMessage

   197

            self._LogMessage.restype = ctypes.c_int

   198

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

   199

   200

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

   201

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   202

            self._GetLogMessage.restype = ctypes.c_uint32

   203

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

   204

   205

            self._loading_error = None

   206

   207

            self.PythonRuntimeInit()

   208

   209

            return True

   210

        except:

   211

            self._loading_error = traceback.format_exc()

   212

            PLCprint(self._loading_error)

   213

            return False

   214

   215

    def UnLoadPLC(self):

   216

        self.PythonRuntimeCleanup()

   217

        self._FreePLC()

   218

   219

    def _FreePLC(self):

   220

        """

   221

        Unload PLC library.

   222

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

   223

        """

   224

        self.PLClibraryLock.acquire()

   225

        # Forget all refs to library

   226

        self._startPLC = lambda x,y:None

   227

        self._stopPLC = lambda:None

   228

        self._ResetDebugVariables = lambda:None

   229

        self._RegisterDebugVariable = lambda x, y:None

   230

        self._IterDebugData = lambda x,y:None

   231

        self._FreeDebugData = lambda:None

   232

        self._GetDebugData = lambda:-1

   233

        self._suspendDebug = lambda x:-1

   234

        self._resumeDebug = lambda:None

   235

        self._PythonIterator = lambda:""

   236

        self._GetLogCount = None 

   237

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

   238

        self._GetLogMessage = None

   239

        self.PLClibraryHandle = None

   240

        # Unload library explicitely

   241

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

   242

            dlclose(self._PLClibraryHandle)

   243

            self._PLClibraryHandle = None

   244

   245

        self.PLClibraryLock.release()

   246

        return False

   247

   248

    def PythonRuntimeCall(self, methodname):

   249

        """ 

   250

        Calls init, start, stop or cleanup method provided by 

   251

        runtime python files, loaded when new PLC uploaded

   252

        """

   253

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

   254

            res,exp = self.evaluator(method)

   255

            if exp is not None: 

   256

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

   257

   258

    def PythonRuntimeInit(self):

   259

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

   260

        self.python_runtime_vars = globals().copy()

   261

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

   262

        self.python_runtime_vars["website"] = self.website

   263

        for methodname in MethodNames :

   264

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

   265

        self.python_runtime_vars["PLCObject"] = self

   266

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

   267

        class PLCSafeGlobals:

   268

            def __getattr__(_self, name):

   269

                try :

   270

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

   271

                except KeyError:

   272

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

   273

                v = t()

   274

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

   275

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

   276

            def __setattr__(_self, name, value):

   277

                try :

   278

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

   279

                except KeyError:

   280

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

   281

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

   282

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

   283

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

   284

        try:

   285

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

   286

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

   287

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

   288

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

   289

                    for methodname in MethodNames: 

   290

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

   291

                        if method is not None:

   292

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

   293

        except:

   294

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

   295

            raise

   296

   297

        self.PythonRuntimeCall("init")

   298

   299

        if self.website is not None:

   300

            self.website.PLCStarted()

   301

   302

   303

    def PythonRuntimeCleanup(self):

   304

        if self.python_runtime_vars is not None:

   305

            self.PythonRuntimeCall("cleanup")

   306

   307

        if self.website is not None:

   308

            self.website.PLCStopped()

   309

   310

        self.python_runtime_vars = None

   311

   312

    def PythonThreadProc(self):

   313

        self.PLCStatus = "Started"

   314

        self.StatusChange()

   315

        self.StartSem.release()

   316

        self.PythonRuntimeCall("start")

   317

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

   318

        compile_cache={}

   319

        while True:

   320

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

   321

            cmd = self._PythonIterator(res,blkid)

   322

            FBID = blkid.value 

   323

            # print " -> ", cmd, blkid

   324

            if cmd is None:

   325

                break

   326

            try :

   327

                self.python_runtime_vars["FBID"]=FBID

   328

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

   329

                if ccmd is None or ccmd!=cmd:

   330

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

   331

                    compile_cache[FBID]=(cmd,AST)

   333

                if exp is not None: 

   334

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

   335

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

   336

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

   337

                else:

   338

                    res=str(result)

   339

                self.python_runtime_vars["FBID"]=None

   340

            except Exception,e:

   341

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

   342

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

   343

        self.PLCStatus = "Stopped"

   344

        self.StatusChange()

   345

        self.PythonRuntimeCall("stop")

   346

   347

    def StartPLC(self):

   348

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

   349

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

   350

            error = None

   351

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

   352

            if res == 0:

   353

                self.StartSem=Semaphore(0)

   354

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

   355

                self.PythonThread.start()

   356

                self.StartSem.acquire()

   357

                self.LogMessage("PLC started")

   358

            else:

   359

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

   360

                self.PLCStatus = "Broken"

   361

                self.StatusChange()

   362

   363

    def StopPLC(self):

   364

        if self.PLCStatus == "Started":

   365

            self.LogMessage("PLC stopped")

   366

            self._stopPLC()

   367

            self.PythonThread.join()

   368

            return True

   369

        return False

   370

   371

    def _Reload(self):

   372

        self.daemon.shutdown(True)

   373

        self.daemon.sock.close()

   374

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

   375

        # never reached

   376

        return 0

   377

   378

    def ForceReload(self):

   379

        # respawn python interpreter

   380

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

   381

        return True

   382

   383

    def GetPLCstatus(self):

   384

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

   385

   386

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

   387

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

   388

            NewFileName = md5sum + lib_ext

   389

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

   390

   391

            self.UnLoadPLC()

   392

   393

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

   394

            self.PLCStatus = "Empty"

   395

   396

            try:

   397

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

   398

                                       self.CurrentPLCFilename))

   399

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

   400

                    try:

   401

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

   402

                    except:

   403

                        pass

   404

            except:

   405

                pass

   406

   407

            try:

   408

                # Create new PLC file

   409

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

   410

                     'wb').write(data)

   411

   412

                # Store new PLC filename based on md5 key

   413

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

   414

   415

                # Then write the files

   416

                log = file(extra_files_log, "w")

   417

                for fname,fdata in extrafiles:

   418

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

   419

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

   420

                    log.write(fname+'\n')

   421

   422

                # Store new PLC filename

   423

                self.CurrentPLCFilename = NewFileName

   424

            except:

   425

                self.PLCStatus = "Broken"

   426

                self.StatusChange()

   427

                PLCprint(traceback.format_exc())

   428

                return False

   429

   430

            if self.LoadPLC():

   431

                self.PLCStatus = "Stopped"

   432

            else:

   433

                self.PLCStatus = "Broken"

   434

                self._FreePLC()

   435

            self.StatusChange()

   436

   437

            return self.PLCStatus == "Stopped"

   438

        return False

   439

   440

    def MatchMD5(self, MD5):

   441

        try:

   442

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

   443

            return last_md5 == MD5

   444

        except:

   445

            return False

   446

   447

   448

   449

    def SetTraceVariablesList(self, idxs):

   450

        """

   451

        Call ctype imported function to append 

   452

        these indexes to registred variables in PLC debugger

   453

        """

   454

        if idxs:

   455

            # suspend but dont disable

   456

            if self._suspendDebug(False) == 0:

   457

                # keep a copy of requested idx

   458

                self._Idxs = idxs[:]

   459

                self._ResetDebugVariables()

   460

                for idx,iectype,force in idxs:

   461

                    if force !=None:

   462

                        c_type,unpack_func, pack_func = \

   463

                            TypeTranslator.get(iectype,

   464

                                                    (None,None,None))

   465

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

   466

                    self._RegisterDebugVariable(idx, force)

   467

                self._resumeDebug()

   468

        else:

   469

            self._suspendDebug(True)

   470

            self._Idxs =  []

   471

   472

    def GetTraceVariables(self):

   473

        """

   474

        Return a list of variables, corresponding to the list of required idx

   475

        """

   476

        if self.PLCStatus == "Started":

   477

            tick = ctypes.c_uint32()

   478

            size = ctypes.c_uint32()

   479

            buff = ctypes.c_void_p()

   480

            TraceVariables = None

   481

            if self.PLClibraryLock.acquire(False):

   482

                if self._GetDebugData(ctypes.byref(tick),

   483

                                      ctypes.byref(size),

   484