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

    93

    94

    def GetLogCount(self, level):

    95

        if self._GetLogCount is not None :

    96

            return int(self._GetLogCount(level))

    97

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

    98

            return 1;

    99

   100

    def GetLogMessage(self, level, msgid):

   101

        tick = ctypes.c_uint32()

   102

        tv_sec = ctypes.c_uint32()

   103

        tv_nsec = ctypes.c_uint32()

   104

        if self._GetLogMessage is not None:

   105

            maxsz = len(self._log_read_buffer)-1

   106

            sz = self._GetLogMessage(level, msgid, 

   107

                self._log_read_buffer, maxsz,

   108

                ctypes.byref(tick),

   109

                ctypes.byref(tv_sec),

   110

                ctypes.byref(tv_nsec))

   111

            if sz and sz <= maxsz:

   112

                self._log_read_buffer[sz] = '\x00'

   113

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

   114

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

   115

            return self._loading_error,0,0,0

   116

        return None

   117

   118

    def _GetMD5FileName(self):

   119

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

   120

   121

    def _GetLibFileName(self):

   122

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

   123

   124

   125

    def LoadPLC(self):

   126

        """

   127

        Load PLC library

   128

        Declare all functions, arguments and return values

   129

        """

   130

        try:

   131

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

   132

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

   133

   134

            self._startPLC = self.PLClibraryHandle.startPLC

   135

            self._startPLC.restype = ctypes.c_int

   136

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

   137

   138

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   139

            self._stopPLC_real.restype = None

   140

   141

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

   142

            if self._PythonIterator is not None:

   143

                self._PythonIterator.restype = ctypes.c_char_p

   144

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

   145

   146

                self._stopPLC = self._stopPLC_real

   147

            else:

   148

                # If python confnode is not enabled, we reuse _PythonIterator

   149

                # as a call that block pythonthread until StopPLC 

   150

                self.PythonIteratorLock = Lock()

   151

                self.PythonIteratorLock.acquire()

   152

                def PythonIterator(res, blkid):

   153

                    self.PythonIteratorLock.acquire()

   154

                    self.PythonIteratorLock.release()

   155

                    return None

   156

                self._PythonIterator = PythonIterator

   157

   158

                def __StopPLC():

   159

                    self._stopPLC_real()

   160

                    self.PythonIteratorLock.release()

   161

                self._stopPLC = __StopPLC

   162

   163

   164

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   165

            self._ResetDebugVariables.restype = None

   166

   167

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   168

            self._RegisterDebugVariable.restype = None

   169

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

   170

   171

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   172

            self._FreeDebugData.restype = None

   173

   174

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   175

            self._GetDebugData.restype = ctypes.c_int  

   176

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

   177

   178

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   179

            self._suspendDebug.restype = ctypes.c_int

   180

            self._suspendDebug.argtypes = [ctypes.c_int]

   181

   182

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   183

            self._resumeDebug.restype = None

   184

   185

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   186

            self._GetLogCount.restype = ctypes.c_uint32

   187

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   188

   189

            self._LogMessage = self.PLClibraryHandle.LogMessage

   190

            self._LogMessage.restype = ctypes.c_int

   191

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

   192

   193

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

   194

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   195

            self._GetLogMessage.restype = ctypes.c_uint32

   196

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

   197

   198

            self._loading_error = None

   199

   200

            self.PythonRuntimeInit()

   201

   202

            return True

   203

        except:

   204

            self._loading_error = traceback.format_exc()

   205

            PLCprint(self._loading_error)

   206

            return False

   207

   208

    def UnLoadPLC(self):

   209

        self.PythonRuntimeCleanup()

   210

        self._FreePLC()

   211

   212

    def _FreePLC(self):

   213

        """

   214

        Unload PLC library.

   215

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

   216

        """

   217

        self.PLClibraryLock.acquire()

   218

        # Forget all refs to library

   219

        self._startPLC = lambda x,y:None

   220

        self._stopPLC = lambda:None

   221

        self._ResetDebugVariables = lambda:None

   222

        self._RegisterDebugVariable = lambda x, y:None

   223

        self._IterDebugData = lambda x,y:None

   224

        self._FreeDebugData = lambda:None

   225

        self._GetDebugData = lambda:-1

   226

        self._suspendDebug = lambda x:-1

   227

        self._resumeDebug = lambda:None

   228

        self._PythonIterator = lambda:""

   229

        self._GetLogCount = None 

   230

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

   231

        self._GetLogMessage = None

   232

        self.PLClibraryHandle = None

   233

        # Unload library explicitely

   234

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

   235

            dlclose(self._PLClibraryHandle)

   236

            self._PLClibraryHandle = None

   237

   238

        self.PLClibraryLock.release()

   239

        return False

   240

   241

    def PythonRuntimeCall(self, methodname):

   242

        """ 

   243

        Calls init, start, stop or cleanup method provided by 

   244

        runtime python files, loaded when new PLC uploaded

   245

        """

   246

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

   247

            res,exp = self.evaluator(method)

   248

            if exp is not None: 

   249

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

   250

   251

    def PythonRuntimeInit(self):

   252

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

   253

        self.python_runtime_vars = globals().copy()

   254

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

   255

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

   256

        for methodname in MethodNames :

   257

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

   258

        self.python_runtime_vars["PLCObject"] = self

   259

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

   260

   261

        try:

   262

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

   263

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

   264

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

   265

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

   266

                    for methodname in MethodNames: 

   267

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

   268

                        if method is not None:

   269

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

   270

   271

        except:

   272

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

   273

            raise

   274

   275

        self.PythonRuntimeCall("init")

   276

   277

        if self.website is not None:

   278

            self.website.PLCStarted()

   279

   280

   281

    def PythonRuntimeCleanup(self):

   282

        if self.python_runtime_vars is not None:

   283

            self.PythonRuntimeCall("cleanup")

   284

   285

        if self.website is not None:

   286

            self.website.PLCStopped()

   287

   288

        self.python_runtime_vars = None

   289

   290

    def PythonThreadProc(self):

   291

        self.PLCStatus = "Started"

   292

        self.StatusChange()

   293

        self.StartSem.release()

   294

        self.PythonRuntimeCall("start")

   295

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

   296

        compile_cache={}

   297

        while True:

   298

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

   299

            cmd = self._PythonIterator(res,blkid)

   300

            FBID = blkid.value 

   301

            # print " -> ", cmd, blkid

   302

            if cmd is None:

   303

                break

   304

            try :

   305

                self.python_runtime_vars["FBID"]=FBID

   306

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

   307

                if ccmd is None or ccmd!=cmd:

   308

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

   309

                    compile_cache[FBID]=(cmd,AST)

   310

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

   311

                if exp is not None: 

   312

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

   313

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

   314

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

   315

                else:

   316

                    res=str(result)

   317

                self.python_runtime_vars["FBID"]=None

   318

            except Exception,e:

   319

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

   320

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

   321

        self.PLCStatus = "Stopped"

   322

        self.StatusChange()

   323

        self.PythonRuntimeCall("stop")

   324

   325

    def StartPLC(self):

   326

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

   327

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

   328

            error = None

   329

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

   330

            if res == 0:

   331

                self.StartSem=Semaphore(0)

   332

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

   333

                self.PythonThread.start()

   334

                self.StartSem.acquire()

   335

                self.LogMessage("PLC started")

   336

            else:

   337

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

   338

                self.PLCStatus = "Broken"

   339

                self.StatusChange()

   340

   341

    def StopPLC(self):

   342

        if self.PLCStatus == "Started":

   343

            self.LogMessage("PLC stopped")

   344

            self._stopPLC()

   345

            self.PythonThread.join()

   346

            return True

   347

        return False

   348

   349

    def _Reload(self):

   350

        self.daemon.shutdown(True)

   351

        self.daemon.sock.close()

   352

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

   353

        # never reached

   354

        return 0

   355

   356

    def ForceReload(self):

   357

        # respawn python interpreter

   358

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

   359

        return True

   360

   361

    def GetPLCstatus(self):

   362

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

   363

   364

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

   365

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

   366

            NewFileName = md5sum + lib_ext

   367

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

   368

   369

            self.UnLoadPLC()

   370

   371

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

   372

            self.PLCStatus = "Empty"

   373

   374

            try:

   375

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

   376

                                       self.CurrentPLCFilename))

   377

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

   378

                    try:

   379

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

   380

                    except:

   381

                        pass

   382

            except:

   383

                pass

   384

   385

            try:

   386

                # Create new PLC file

   387

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

   388

                     'wb').write(data)

   389

   390

                # Store new PLC filename based on md5 key

   391

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

   392

   393

                # Then write the files

   394

                log = file(extra_files_log, "w")

   395

                for fname,fdata in extrafiles:

   396

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

   397

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

   398

                    log.write(fname+'\n')

   399

   400

                # Store new PLC filename

   401

                self.CurrentPLCFilename = NewFileName

   402

            except:

   403

                self.PLCStatus = "Broken"

   404

                self.StatusChange()

   405

                PLCprint(traceback.format_exc())

   406

                return False

   407

   408

            if self.LoadPLC():

   409

                self.PLCStatus = "Stopped"

   410

            else:

   411

                self.PLCStatus = "Broken"

   412

                self._FreePLC()

   413

            self.StatusChange()

   414

   415

            return self.PLCStatus == "Stopped"

   416

        return False

   417

   418

    def MatchMD5(self, MD5):

   419

        try:

   420

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

   421

            return last_md5 == MD5

   422

        except:

   423

            return False

   424

   425

   426

   427

    def SetTraceVariablesList(self, idxs):

   428

        """

   429

        Call ctype imported function to append 

   430

        these indexes to registred variables in PLC debugger

   431

        """

   432

        if idxs:

   433

            # suspend but dont disable

   434

            if self._suspendDebug(False) == 0:

   435

                # keep a copy of requested idx

   436

                self._Idxs = idxs[:]

   437

                self._ResetDebugVariables()

   438

                for idx,iectype,force in idxs:

   439

                    if force !=None:

   440

                        c_type,unpack_func, pack_func = \

   441

                            TypeTranslator.get(iectype,

   442

                                                    (None,None,None))

   443

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

   444

                    self._RegisterDebugVariable(idx, force)

   445

                self._resumeDebug()

   446

        else:

   447

            self._suspendDebug(True)

   448

            self._Idxs =  []

   449

   450

    def GetTraceVariables(self):

   451

        """

   452

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

   453

        """

   454

        if self.PLCStatus == "Started":

   455

            tick = ctypes.c_uint32()

   456

            size = ctypes.c_uint32()

   457

            buff = ctypes.c_void_p()

   458

            TraceVariables = None

   459

            if self.PLClibraryLock.acquire(False):

   460

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

   461

                                      ctypes.byref(size),

   462

                                      ctypes.byref(buff)) == 0:

   463

                    if size.value:

   464

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

   465

                    self._FreeDebugData()

   466

                self.PLClibraryLock.release()

   467

            if TraceVariables is not None:

   468

                return self.PLCStatus, tick.value, TraceVariables

   469

        return self.PLCStatus, None, []

   470

   471

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

   472

        try:

   473

            exec script in kwargs

   474

        except:

   475

            e_type, e_value, e_traceback = sys.exc_info()

   476

            line_no = traceback.tb_lineno(get_last_traceback(e_traceback))

   477

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

   478

                        (line_no, e_value, script.splitlines()[line_no - 1]))

   479

        return (0, kwargs.get("returnVal", None))

   480

   481