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 program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 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

            if self.LoadPLC():

    83

                self.PLCStatus = "Stopped"

    84

        except Exception, e:

    85

            self.PLCStatus = "Empty"

    86

            self.CurrentPLCFilename=None

    87

    88

    def StatusChange(self):

    89

        if self.statuschange is not None:

    90

            for callee in self.statuschange:

    91

                callee(self.PLCStatus)

    92

    93

    def LogMessage(self, *args):

    94

        if len(args) == 2:

    95

            level, msg = args

    96

        else:

    97

            level = LogLevelsDefault

    98

            msg, = args

    99

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

   100

   101

    def ResetLogCount(self):

   102

        if self._ResetLogCount is not None:

   103

            self._ResetLogCount()

   104

   105

    def GetLogCount(self, level):

   106

        if self._GetLogCount is not None :

   107

            return int(self._GetLogCount(level))

   108

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

   109

            return 1

   110

   111

    def GetLogMessage(self, level, msgid):

   112

        tick = ctypes.c_uint32()

   113

        tv_sec = ctypes.c_uint32()

   114

        tv_nsec = ctypes.c_uint32()

   115

        if self._GetLogMessage is not None:

   116

            maxsz = len(self._log_read_buffer)-1

   117

            sz = self._GetLogMessage(level, msgid,

   118

                self._log_read_buffer, maxsz,

   119

                ctypes.byref(tick),

   120

                ctypes.byref(tv_sec),

   121

                ctypes.byref(tv_nsec))

   122

            if sz and sz <= maxsz:

   123

                self._log_read_buffer[sz] = '\x00'

   124

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

   125

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

   126

            return self._loading_error,0,0,0

   127

        return None

   128

   129

    def _GetMD5FileName(self):

   130

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

   131

   132

    def _GetLibFileName(self):

   133

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

   134

   135

   136

    def LoadPLC(self):

   137

        """

   138

        Load PLC library

   139

        Declare all functions, arguments and return values

   140

        """

   141

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

   142

        try:

   143

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

   144

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

   145

   146

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

   147

            if len(md5) == 32 : 

   148

                self.PLC_ID.value = md5 

   149

   150

            self._startPLC = self.PLClibraryHandle.startPLC

   151

            self._startPLC.restype = ctypes.c_int

   152

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

   153

   154

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   155

            self._stopPLC_real.restype = None

   156

   157

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

   158

            if self._PythonIterator is not None:

   159

                self._PythonIterator.restype = ctypes.c_char_p

   160

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

   161

   162

                self._stopPLC = self._stopPLC_real

   163

            else:

   164

                # If python confnode is not enabled, we reuse _PythonIterator

   165

                # as a call that block pythonthread until StopPLC

   166

                self.PlcStopping = Event()

   167

                def PythonIterator(res, blkid):

   168

                    self.PlcStopping.clear()

   169

                    self.PlcStopping.wait()

   170

                    return None

   171

                self._PythonIterator = PythonIterator

   172

   173

                def __StopPLC():

   174

                    self._stopPLC_real()

   175

                    self.PlcStopping.set()

   176

                self._stopPLC = __StopPLC

   177

   178

   179

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   180

            self._ResetDebugVariables.restype = None

   181

   182

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   183

            self._RegisterDebugVariable.restype = None

   184

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

   185

   186

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   187

            self._FreeDebugData.restype = None

   188

   189

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   190

            self._GetDebugData.restype = ctypes.c_int

   191

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

   192

   193

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   194

            self._suspendDebug.restype = ctypes.c_int

   195

            self._suspendDebug.argtypes = [ctypes.c_int]

   196

   197

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   198

            self._resumeDebug.restype = None

   199

   200

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   201

            self._ResetLogCount.restype = None

   202

   203

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   204

            self._GetLogCount.restype = ctypes.c_uint32

   205

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   206

   207

            self._LogMessage = self.PLClibraryHandle.LogMessage

   208

            self._LogMessage.restype = ctypes.c_int

   209

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

   210

   211

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

   212

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   213

            self._GetLogMessage.restype = ctypes.c_uint32

   214

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

   215

   216

            self._loading_error = None

   217

   218

            self.PythonRuntimeInit()

   219

   220

            return True

   221

        except:

   222

            self._loading_error = traceback.format_exc()

   223

            PLCprint(self._loading_error)

   224

            return False

   225

   226

    def UnLoadPLC(self):

   227

        self.PythonRuntimeCleanup()

   228

        self._FreePLC()

   229

   230

    def _FreePLC(self):

   231

        """

   232

        Unload PLC library.

   233

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

   234

        """

   235

        self.PLClibraryLock.acquire()

   236

        # Forget all refs to library

   237

        self._startPLC = lambda x,y:None

   238

        self._stopPLC = lambda:None

   239

        self._ResetDebugVariables = lambda:None

   240

        self._RegisterDebugVariable = lambda x, y:None

   241

        self._IterDebugData = lambda x,y:None

   242

        self._FreeDebugData = lambda:None

   243

        self._GetDebugData = lambda:-1

   244

        self._suspendDebug = lambda x:-1

   245

        self._resumeDebug = lambda:None

   246

        self._PythonIterator = lambda:""

   247

        self._GetLogCount = None

   248

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

   249

        self._GetLogMessage = None

   250

        self.PLClibraryHandle = None

   251

        # Unload library explicitely

   252

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

   253

            dlclose(self._PLClibraryHandle)

   254

            self._PLClibraryHandle = None

   255

   256

        self.PLClibraryLock.release()

   257

        return False

   258

   259

    def PythonRuntimeCall(self, methodname):

   260

        """

   261

        Calls init, start, stop or cleanup method provided by

   262

        runtime python files, loaded when new PLC uploaded

   263

        """

   264

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

   265

            res,exp = self.evaluator(method)

   266

            if exp is not None:

   267

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

   268

   269

    def PythonRuntimeInit(self):

   270

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

   271

        self.python_runtime_vars = globals().copy()

   272

        self.python_runtime_vars.update(self.pyruntimevars)

   273

   274

        class PLCSafeGlobals:

   275

            def __getattr__(_self, name):

   276

                try :

   277

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

   278

                except KeyError:

   279

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

   280

                v = t()

   281

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

   282

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

   283

            def __setattr__(_self, name, value):

   284

                try :

   285

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

   286

                except KeyError:

   287

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

   288

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

   289

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

   290

   291

        self.python_runtime_vars.update({

   292

            "PLCGlobals" : PLCSafeGlobals(),

   293

            "WorkingDir" : self.workingdir,

   294

            "PLCObject"  : self,

   295

            "PLCBinary"  : self.PLClibraryHandle,

   296

            "PLCGlobalsDesc" : []})

   297

   298

        for methodname in MethodNames :

   299

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

   300

   301

        try:

   302

            filenames = os.listdir(self.workingdir)

   303

            filenames.sort()

   304

            for filename in filenames:

   305

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

   306

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

   307

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

   308

                    for methodname in MethodNames:

   309

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

   310

                        if method is not None:

   311

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

   312

        except:

   313

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

   314

            raise

   315

   316

        self.PythonRuntimeCall("init")

   317

   318

   319

   320

    def PythonRuntimeCleanup(self):

   321

        if self.python_runtime_vars is not None:

   322

            self.PythonRuntimeCall("cleanup")

   323

   324

        self.python_runtime_vars = None

   325

   326

    def PythonThreadProc(self):

   327

        self.StartSem.release()

   328

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

   329

        compile_cache={}

   330

        while True:

   331

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

   332

            cmd = self._PythonIterator(res,blkid)

   333

            FBID = blkid.value

   334

            # print " -> ", cmd, blkid

   335

            if cmd is None:

   336

                break

   337

            try :

   338

                self.python_runtime_vars["FBID"]=FBID

   339

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

   340

                if ccmd is None or ccmd!=cmd:

   341

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

   342

                    compile_cache[FBID]=(cmd,AST)

   343

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

   344

                if exp is not None:

   345

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

   346

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

   347

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

   348

                else:

   349

                    res=str(result)

   350

                self.python_runtime_vars["FBID"]=None

   351

            except Exception,e:

   352

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

   353

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

   354

   355

    def StartPLC(self):

   356

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

   357

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

   358

            error = None

   359

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

   360

            if res == 0:

   361

                self.PLCStatus = "Started"

   362

                self.StatusChange()

   363

                self.PythonRuntimeCall("start")

   364

                self.StartSem=Semaphore(0)

   365

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

   366

                self.PythonThread.start()

   367

                self.StartSem.acquire()

   368

                self.LogMessage("PLC started")

   369

            else:

   370

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

   371

                self.PLCStatus = "Broken"

   372

                self.StatusChange()

   373

   374

    def StopPLC(self):

   375

        if self.PLCStatus == "Started":

   376

            self.LogMessage("PLC stopped")

   377

            self._stopPLC()

   378

            self.PythonThread.join()

   379

            self.PLCStatus = "Stopped"

   380

            self.StatusChange()

   381

            self.PythonRuntimeCall("stop")

   382

            if self.TraceThread is not None :

   383

                self.TraceWakeup.set()

   384

                self.TraceThread.join()

   385

                self.TraceThread = None

   386

            return True

   387

        return False

   388

   389

    def _Reload(self):

   390

        self.daemon.shutdown(True)

   391

        self.daemon.sock.close()

   392

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

   393

        # never reached

   394

        return 0

   395

   396

    def ForceReload(self):

   397

        # respawn python interpreter

   398

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

   399

        return True

   400

   401

    def GetPLCstatus(self):

   402

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

   403

   404

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

   405

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

   406

            NewFileName = md5sum + lib_ext

   407

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

   408

   409

            self.UnLoadPLC()

   410

   411

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

   412

            self.PLCStatus = "Empty"

   413

   414

            try:

   415

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

   416

                                       self.CurrentPLCFilename))

   417

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

   418

                    try:

   419

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

   420

                    except:

   421

                        pass

   422

            except:

   423

                pass

   424

   425

            try:

   426

                # Create new PLC file

   427

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

   428

                     'wb').write(data)

   429

   430

                # Store new PLC filename based on md5 key

   431

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

   432

   433

                # Then write the files

   434

                log = file(extra_files_log, "w")

   435

                for fname,fdata in extrafiles:

   436

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

   437

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

   438

                    log.write(fname+'\n')

   439

   440

                # Store new PLC filename

   441

                self.CurrentPLCFilename = NewFileName

   442

            except:

   443

                self.PLCStatus = "Broken"

   444

                self.StatusChange()

   445

                PLCprint(traceback.format_exc())

   446

                return False

   447

   448

            if self.LoadPLC():

   449

                self.PLCStatus = "Stopped"

   450

            else:

   451

                self.PLCStatus = "Broken"

   452

                self._FreePLC()

   453

            self.StatusChange()

   454

   455

            return self.PLCStatus == "Stopped"

   456

        return False

   457

   458

    def MatchMD5(self, MD5):

   459

        try:

   460

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

   461

            return last_md5 == MD5

   462

        except:

   463

            pass

   464

        return False

   465

   466

    def SetTraceVariablesList(self, idxs):

   467

        """

   468

        Call ctype imported function to append

   469

        these indexes to registred variables in PLC debugger

   470

        """

   471

        if idxs:

   472

            # suspend but dont disable

   473

            if self._suspendDebug(False) == 0:

   474

                # keep a copy of requested idx

   475

                self._ResetDebugVariables()

   476

                for idx,iectype,force in idxs:

   477

                    if force !=None:

   478

                        c_type,unpack_func, pack_func = \

   479

                            TypeTranslator.get(iectype,

   480

                                                    (None,None,None))

   481

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