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

        except Exception, e:

    78

            self.PLCStatus = "Empty"

    79

            self.CurrentPLCFilename=None

    80

    81

    def StatusChange(self):

    82

        if self.statuschange is not None:

    83

            self.statuschange(self.PLCStatus)

    84

    85

    def LogMessage(self, *args):

    86

        if len(args) == 2:

    87

            level, msg = args

    88

        else:

    89

            level = LogLevelsDefault

    90

            msg, = args

    91

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

    92

    96

    97

    def GetLogCount(self, level):

    98

        if self._GetLogCount is not None :

    99

            return int(self._GetLogCount(level))

   100

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

   102

   103

    def GetLogMessage(self, level, msgid):

   104

        tick = ctypes.c_uint32()

   105

        tv_sec = ctypes.c_uint32()

   106

        tv_nsec = ctypes.c_uint32()

   107

        if self._GetLogMessage is not None:

   108

            maxsz = len(self._log_read_buffer)-1

   109

            sz = self._GetLogMessage(level, msgid, 

   110

                self._log_read_buffer, maxsz,

   111

                ctypes.byref(tick),

   112

                ctypes.byref(tv_sec),

   113

                ctypes.byref(tv_nsec))

   114

            if sz and sz <= maxsz:

   115

                self._log_read_buffer[sz] = '\x00'

   116

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

   117

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

   118

            return self._loading_error,0,0,0

   119

        return None

   120

   121

    def _GetMD5FileName(self):

   122

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

   123

   124

    def _GetLibFileName(self):

   125

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

   126

   127

   128

    def LoadPLC(self):

   129

        """

   130

        Load PLC library

   131

        Declare all functions, arguments and return values

   132

        """

   133

        try:

   134

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

   135

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

   136

   137

            self._startPLC = self.PLClibraryHandle.startPLC

   138

            self._startPLC.restype = ctypes.c_int

   139

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

   140

   141

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   142

            self._stopPLC_real.restype = None

   143

   144

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

   145

            if self._PythonIterator is not None:

   146

                self._PythonIterator.restype = ctypes.c_char_p

   147

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

   148

   149

                self._stopPLC = self._stopPLC_real

   150

            else:

   151

                # If python confnode is not enabled, we reuse _PythonIterator

   152

                # as a call that block pythonthread until StopPLC 

   153

                self.PythonIteratorLock = Lock()

   154

                self.PythonIteratorLock.acquire()

   155

                def PythonIterator(res, blkid):

   156

                    self.PythonIteratorLock.acquire()

   157

                    self.PythonIteratorLock.release()

   158

                    return None

   159

                self._PythonIterator = PythonIterator

   160

   161

                def __StopPLC():

   162

                    self._stopPLC_real()

   163

                    self.PythonIteratorLock.release()

   164

                self._stopPLC = __StopPLC

   165

   166

   167

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   168

            self._ResetDebugVariables.restype = None

   169

   170

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   171

            self._RegisterDebugVariable.restype = None

   172

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

   173

   174

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   175

            self._FreeDebugData.restype = None

   176

   177

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   178

            self._GetDebugData.restype = ctypes.c_int  

   179

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

   180

   181

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   182

            self._suspendDebug.restype = ctypes.c_int

   183

            self._suspendDebug.argtypes = [ctypes.c_int]

   184

   185

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   186

            self._resumeDebug.restype = None

   187

   191

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   192

            self._GetLogCount.restype = ctypes.c_uint32

   193

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   194

   195

            self._LogMessage = self.PLClibraryHandle.LogMessage

   196

            self._LogMessage.restype = ctypes.c_int

   197

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

   199

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

   200

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   201

            self._GetLogMessage.restype = ctypes.c_uint32

   202

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

   203

   204

            self._loading_error = None

   205

   206

            self.PythonRuntimeInit()

   207

   208

            return True

   209

        except:

   210

            self._loading_error = traceback.format_exc()

   211

            PLCprint(self._loading_error)

   212

            return False

   213

   214

    def UnLoadPLC(self):

   215

        self.PythonRuntimeCleanup()

   216

        self._FreePLC()

   217

   218

    def _FreePLC(self):

   219

        """

   220

        Unload PLC library.

   221

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

   222

        """

   223

        self.PLClibraryLock.acquire()

   224

        # Forget all refs to library

   225

        self._startPLC = lambda x,y:None

   226

        self._stopPLC = lambda:None

   227

        self._ResetDebugVariables = lambda:None

   228

        self._RegisterDebugVariable = lambda x, y:None

   229

        self._IterDebugData = lambda x,y:None

   230

        self._FreeDebugData = lambda:None

   231

        self._GetDebugData = lambda:-1

   232

        self._suspendDebug = lambda x:-1

   233

        self._resumeDebug = lambda:None

   234

        self._PythonIterator = lambda:""

   235

        self._GetLogCount = None 

   236

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

   237

        self._GetLogMessage = None

   238

        self.PLClibraryHandle = None

   239

        # Unload library explicitely

   240

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

   241

            dlclose(self._PLClibraryHandle)

   242

            self._PLClibraryHandle = None

   243

   244

        self.PLClibraryLock.release()

   245

        return False

   246

   247

    def PythonRuntimeCall(self, methodname):

   248

        """ 

   249

        Calls init, start, stop or cleanup method provided by 

   250

        runtime python files, loaded when new PLC uploaded

   251

        """

   252

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

   253

            res,exp = self.evaluator(method)

   254

            if exp is not None: 

   255

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

   256

   257

    def PythonRuntimeInit(self):

   258

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

   259

        self.python_runtime_vars = globals().copy()

   260

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

   261

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

   262

        for methodname in MethodNames :

   263

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

   264

        self.python_runtime_vars["PLCObject"] = self

   265

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

   266

   267

        try:

   268

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

   269

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

   270

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

   271

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

   272

                    for methodname in MethodNames: 

   273

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

   274

                        if method is not None:

   275

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

   276

   277

        except:

   278

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

   279

            raise

   280

   281

        self.PythonRuntimeCall("init")

   282

   283

        if self.website is not None:

   284

            self.website.PLCStarted()

   285

   286

   287

    def PythonRuntimeCleanup(self):

   288

        if self.python_runtime_vars is not None:

   289

            self.PythonRuntimeCall("cleanup")

   290

   291

        if self.website is not None:

   292

            self.website.PLCStopped()

   293

   294

        self.python_runtime_vars = None

   295

   296

    def PythonThreadProc(self):

   297

        self.PLCStatus = "Started"

   298

        self.StatusChange()

   299

        self.StartSem.release()

   300

        self.PythonRuntimeCall("start")

   301

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

   302

        compile_cache={}

   303

        while True:

   304

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

   305

            cmd = self._PythonIterator(res,blkid)

   306

            FBID = blkid.value 

   307

            # print " -> ", cmd, blkid

   308

            if cmd is None:

   309

                break

   310

            try :

   311

                self.python_runtime_vars["FBID"]=FBID

   312

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

   313

                if ccmd is None or ccmd!=cmd:

   314

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

   315

                    compile_cache[FBID]=(cmd,AST)

   316

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

   317

                if exp is not None: 

   318

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

   319

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

   320

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

   321

                else:

   322

                    res=str(result)

   323

                self.python_runtime_vars["FBID"]=None

   324

            except Exception,e:

   325

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

   326

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

   327

        self.PLCStatus = "Stopped"

   328

        self.StatusChange()

   329

        self.PythonRuntimeCall("stop")

   330

   331

    def StartPLC(self):

   332

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

   333

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

   334

            error = None

   335

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

   336

            if res == 0:

   337

                self.StartSem=Semaphore(0)

   338

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

   339

                self.PythonThread.start()

   340

                self.StartSem.acquire()

   341

                self.LogMessage("PLC started")

   342

            else:

   343

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

   344

                self.PLCStatus = "Broken"

   345

                self.StatusChange()

   346

   347

    def StopPLC(self):

   348

        if self.PLCStatus == "Started":

   349

            self.LogMessage("PLC stopped")

   350

            self._stopPLC()

   351

            self.PythonThread.join()

   352

            return True

   353

        return False

   354

   355

    def _Reload(self):

   356

        self.daemon.shutdown(True)

   357

        self.daemon.sock.close()

   358

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

   359

        # never reached

   360

        return 0

   361

   362

    def ForceReload(self):

   363

        # respawn python interpreter

   364

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

   365

        return True

   366

   367

    def GetPLCstatus(self):

   368

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

   369

   370

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

   371

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

   372

            NewFileName = md5sum + lib_ext

   373

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

   374

   375

            self.UnLoadPLC()

   376

   377

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

   378

            self.PLCStatus = "Empty"

   379

   380

            try:

   381

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

   382

                                       self.CurrentPLCFilename))

   383

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

   384

                    try:

   385

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

   386

                    except:

   387

                        pass

   388

            except:

   389

                pass

   390

   391

            try:

   392

                # Create new PLC file

   393

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

   394

                     'wb').write(data)

   395

   396

                # Store new PLC filename based on md5 key

   397

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

   398

   399

                # Then write the files

   400

                log = file(extra_files_log, "w")

   401

                for fname,fdata in extrafiles:

   402

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

   403

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

   404

                    log.write(fname+'\n')

   405

   406

                # Store new PLC filename

   407

                self.CurrentPLCFilename = NewFileName

   408

            except:

   409

                self.PLCStatus = "Broken"

   410

                self.StatusChange()

   411

                PLCprint(traceback.format_exc())

   412

                return False

   413

   414

            if self.LoadPLC():

   415

                self.PLCStatus = "Stopped"

   416

            else:

   417

                self.PLCStatus = "Broken"

   418

                self._FreePLC()

   419

            self.StatusChange()

   420

   421

            return self.PLCStatus == "Stopped"

   422

        return False

   423

   424

    def MatchMD5(self, MD5):

   425

        try:

   426

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

   427

            return last_md5 == MD5

   428

        except:

   429

            return False

   430

   431

   432

   433

    def SetTraceVariablesList(self, idxs):

   434

        """

   435

        Call ctype imported function to append 

   436

        these indexes to registred variables in PLC debugger

   437

        """

   438

        if idxs:

   439

            # suspend but dont disable

   440

            if self._suspendDebug(False) == 0:

   441

                # keep a copy of requested idx

   442

                self._Idxs = idxs[:]

   443

                self._ResetDebugVariables()

   444

                for idx,iectype,force in idxs:

   445

                    if force !=None:

   446

                        c_type,unpack_func, pack_func = \

   447

                            TypeTranslator.get(iectype,

   448

                                                    (None,None,None))

   449

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

   450

                    self._RegisterDebugVariable(idx, force)

   451

                self._resumeDebug()

   452

        else:

   453

            self._suspendDebug(True)

   454

            self._Idxs =  []

   455

   456

    def GetTraceVariables(self):

   457

        """

   458

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

   459

        """

   460

        if self.PLCStatus == "Started":

   461

            tick = ctypes.c_uint32()

   462

            size = ctypes.c_uint32()

   463

            buff = ctypes.c_void_p()

   464

            TraceVariables = None

   465

            if self.PLClibraryLock.acquire(False):

   466

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

   467

                                      ctypes.byref(size),

   468

                                      ctypes.byref(buff)) == 0:

   469

                    if size.value:

   470

                        TraceVariables = UnpackDebugBuffer(buff, size.value, self._Idxs)

   471

                    self._FreeDebugData()

   472

                self.PLClibraryLock.release()

   473

            if TraceVariables is not None:

   474

                return self.PLCStatus, tick.value, TraceVariables

   475

        return self.PLCStatus, None, []

   476

   477

    def RemoteExec(self, script, **kwargs):

   478

        try:

   479

            exec script in kwargs

   480

        except:

   481

            e_type, e_value, e_traceback = sys.exc_info()

   482

            line_no = traceback.tb_lineno(get_last_traceback(e_traceback))

   483

            return (-1, "RemoteExec script failed!\n\nLine %d: %s\n\t%s" % 

   484