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, SameEndianessTypeTranslator as TypeTranslator

    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

    71

        # Get the last transfered PLC if connector must be restart

    72

        try:

    73

            self.CurrentPLCFilename=open(

    74

                             self._GetMD5FileName(),

    75

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

    76

        except Exception, e:

    77

            self.PLCStatus = "Empty"

    78

            self.CurrentPLCFilename=None

    79

    80

    def StatusChange(self):

    81

        if self.statuschange is not None:

    82

            self.statuschange(self.PLCStatus)

    83

    84

    def LogMessage(self, *args):

    85

        if len(args) == 2:

    86

            level, msg = args

    87

        else:

    88

            level = LogLevelsDefault

    89

            msg, = args

    90

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

    91

    92

    93

    def GetLogCount(self, level):

    94

        if self._GetLogCount is not None :

    95

            return int(self._GetLogCount(level))

    96

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

    97

            return 1;

    98

    99

    def GetLogMessage(self, level, msgid):

   100

        tick = ctypes.c_uint32()

   101

        tv_sec = ctypes.c_uint32()

   102

        tv_nsec = ctypes.c_uint32()

   103

        if self._GetLogMessage is not None:

   104

            maxsz = len(self._log_read_buffer)-1

   105

            sz = self._GetLogMessage(level, msgid, 

   106

                self._log_read_buffer, maxsz,

   107

                ctypes.byref(tick),

   108

                ctypes.byref(tv_sec),

   109

                ctypes.byref(tv_nsec))

   110

            if sz and sz <= maxsz:

   111

                self._log_read_buffer[sz] = '\x00'

   112

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

   113

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

   114

            return self._loading_error,0,0,0

   115

        return None

   116

   117

    def _GetMD5FileName(self):

   118

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

   119

   120

    def _GetLibFileName(self):

   121

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

   122

   123

   124

    def _LoadNewPLC(self):

   125

        """

   126

        Load PLC library

   127

        Declare all functions, arguments and return values

   128

        """

   129

        try:

   130

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

   131

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

   132

   133

            self._startPLC = self.PLClibraryHandle.startPLC

   134

            self._startPLC.restype = ctypes.c_int

   135

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

   136

   137

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   138

            self._stopPLC_real.restype = None

   139

   140

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

   141

            if self._PythonIterator is not None:

   142

                self._PythonIterator.restype = ctypes.c_char_p

   143

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

   144

   145

                self._stopPLC = self._stopPLC_real

   146

            else:

   147

                # If python confnode is not enabled, we reuse _PythonIterator

   148

                # as a call that block pythonthread until StopPLC 

   149

                self.PythonIteratorLock = Lock()

   150

                self.PythonIteratorLock.acquire()

   151

                def PythonIterator(res, blkid):

   152

                    self.PythonIteratorLock.acquire()

   153

                    self.PythonIteratorLock.release()

   154

                    return None

   155

                self._PythonIterator = PythonIterator

   156

   157

                def __StopPLC():

   158

                    self._stopPLC_real()

   159

                    self.PythonIteratorLock.release()

   160

                self._stopPLC = __StopPLC

   161

   162

   163

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   164

            self._ResetDebugVariables.restype = None

   165

   166

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   167

            self._RegisterDebugVariable.restype = None

   168

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

   169

   170

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   171

            self._FreeDebugData.restype = None

   172

   173

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   174

            self._GetDebugData.restype = ctypes.c_int  

   175

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

   176

   177

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   178

            self._suspendDebug.restype = ctypes.c_int

   179

            self._suspendDebug.argtypes = [ctypes.c_int]

   180

   181

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   182

            self._resumeDebug.restype = None

   183

   184

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   185

            self._GetLogCount.restype = ctypes.c_uint32

   186

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   187

   188

            self._LogMessage = self.PLClibraryHandle.LogMessage

   189

            self._LogMessage.restype = ctypes.c_int

   190

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

   191

   192

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

   193

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   194

            self._GetLogMessage.restype = ctypes.c_uint32

   195

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

   196

   197

            self._loading_error = None

   198

            return True

   199

        except:

   200

            self._loading_error = traceback.format_exc()

   201

            PLCprint(self._loading_error)

   202

            return False

   203

   204

    def _FreePLC(self):

   205

        """

   206

        Unload PLC library.

   207

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

   208

        """

   209

        self.PLClibraryLock.acquire()

   210

        # Forget all refs to library

   211

        self._startPLC = lambda:None

   212

        self._stopPLC = lambda:None

   213

        self._ResetDebugVariables = lambda:None

   214

        self._RegisterDebugVariable = lambda x, y:None

   215

        self._IterDebugData = lambda x,y:None

   216

        self._FreeDebugData = lambda:None

   217

        self._GetDebugData = lambda:-1

   218

        self._suspendDebug = lambda x:-1

   219

        self._resumeDebug = lambda:None

   220

        self._PythonIterator = lambda:""

   221

        self._GetLogCount = None 

   222

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

   223

        self._GetLogMessage = None

   224

        self.PLClibraryHandle = None

   225

        # Unload library explicitely

   226

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

   227

            dlclose(self._PLClibraryHandle)

   228

            self._PLClibraryHandle = None

   229

   230

        self.PLClibraryLock.release()

   231

        return False

   232

   233

    def PrepareRuntimePy(self):

   234

        self.python_threads_vars = globals().copy()

   235

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

   236

        self.python_threads_vars["website"] = self.website

   237

        self.python_threads_vars["_runtime_begin"] = []

   238

        self.python_threads_vars["_runtime_cleanup"] = []

   239

        self.python_threads_vars["PLCObject"] = self

   240

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

   241

   242

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

   243

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

   244

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

   245

                try:

   246

                    # TODO handle exceptions in runtime.py

   247

                    # pyfile may redefine _runtime_cleanup

   248

                    # or even call _PythonThreadProc itself.

   249

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

   250

                except:

   251

                    PLCprint(traceback.format_exc())

   252

                runtime_begin = self.python_threads_vars.get("_%s_begin" % name, None)

   253

                if runtime_begin is not None:

   254

                    self.python_threads_vars["_runtime_begin"].append(runtime_begin)

   255

                runtime_cleanup = self.python_threads_vars.get("_%s_cleanup" % name, None)

   256

                if runtime_cleanup is not None:

   257

                    self.python_threads_vars["_runtime_cleanup"].append(runtime_cleanup)

   258

   259

        for runtime_begin in self.python_threads_vars.get("_runtime_begin", []):

   260

            runtime_begin()

   261

   262

        if self.website is not None:

   263

            self.website.PLCStarted()

   264

   265

    def FinishRuntimePy(self):

   266

        for runtime_cleanup in self.python_threads_vars.get("_runtime_cleanup", []):

   267

            runtime_cleanup()    

   268

        if self.website is not None:

   269

            self.website.PLCStopped()

   270

        self.python_threads_vars = None

   271

   272

    def PythonThreadProc(self):

   273

        self.PLCStatus = "Started"

   274

        self.StatusChange()

   275

        self.StartSem.release()

   276

        self.evaluator(self.PrepareRuntimePy)

   277

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

   278

        compile_cache={}

   279

        while True:

   280

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

   281

            cmd = self._PythonIterator(res,blkid)

   282

            FBID = blkid.value 

   283

            # print " -> ", cmd, blkid

   284

            if cmd is None:

   285

                break

   286

            try :

   287

                self.python_threads_vars["FBID"]=FBID

   288

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

   289

                if ccmd is None or ccmd!=cmd:

   290

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

   291

                    compile_cache[FBID]=(cmd,AST)

   292

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

   293

                if exp is not None: 

   294

                    raise(exp)

   295

                else:

   296

                    res=str(result)

   297

                self.python_threads_vars["FBID"]=None

   298

            except Exception,e:

   299

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

   300

                PLCprint(('*** Python eval EXCEPTION ***\n'+

   301

                          '| Function Block ID: %d\n'+

   302

                          '| Command : "%s"\n'+

   303

                          '| Exception : "%s"')%(FBID,cmd,str(e)))

   304

        self.PLCStatus = "Stopped"

   305

        self.StatusChange()

   306

        self.evaluator(self.FinishRuntimePy)

   307

   308

    def StartPLC(self):

   309

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

   310

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

   311

            error = None

   312

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

   313

            if res == 0:

   314

                self.StartSem=Semaphore(0)

   315

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

   316

                self.PythonThread.start()

   317

                self.StartSem.acquire()

   318

                self.LogMessage("PLC started")

   319

            else:

   320

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

   321

                self.PLCStatus = "Broken"

   322

                self.StatusChange()

   323

   324

    def StopPLC(self):

   325

        if self.PLCStatus == "Started":

   326

            self.LogMessage("PLC stopped")

   327

            self._stopPLC()

   328

            self.PythonThread.join()

   329

            return True

   330

        return False

   331

   332

    def _Reload(self):

   333

        self.daemon.shutdown(True)

   334

        self.daemon.sock.close()

   335

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

   336

        # never reached

   337

        return 0

   338

   339

    def ForceReload(self):

   340

        # respawn python interpreter

   341

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

   342

        return True

   343

   344

    def GetPLCstatus(self):

   345

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

   346

   347

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

   348

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

   349

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

   350

            NewFileName = md5sum + lib_ext

   351

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

   352

   353

            self._FreePLC()

   354

            self.PLCStatus = "Empty"

   355

   356

            try:

   357

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

   358

                                       self.CurrentPLCFilename))

   359

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

   360

                    try:

   361

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

   362

                    except:

   363

                        pass

   364

            except:

   365

                pass

   366

   367

            try:

   368

                # Create new PLC file

   369

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

   370

                     'wb').write(data)

   371

   372

                # Store new PLC filename based on md5 key

   373

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

   374

   375

                # Then write the files

   376

                log = file(extra_files_log, "w")

   377

                for fname,fdata in extrafiles:

   378

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

   379

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

   380

                    log.write(fname+'\n')

   381

   382

                # Store new PLC filename

   383

                self.CurrentPLCFilename = NewFileName

   384

            except:

   385

                self.PLCStatus = "Broken"

   386

                self.StatusChange()

   387

                PLCprint(traceback.format_exc())

   388

                return False

   389

   390

            if self._LoadNewPLC():

   391

                self.PLCStatus = "Stopped"

   392

            else:

   393

                self._FreePLC()

   394

            self.StatusChange()

   395

   396

            return self.PLCStatus == "Stopped"

   397

        return False

   398

   399

    def MatchMD5(self, MD5):

   400

        try:

   401

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

   402

            return last_md5 == MD5

   403

        except:

   404

            return False

   405

   406

   407

   408

    def SetTraceVariablesList(self, idxs):

   409

        """

   410

        Call ctype imported function to append 

   411

        these indexes to registred variables in PLC debugger

   412

        """

   413

        if idxs:

   414

            # suspend but dont disable

   415

            if self._suspendDebug(False) == 0:

   416

                # keep a copy of requested idx

   417

                self._Idxs = idxs[:]

   418

                self._ResetDebugVariables()

   419

                for idx,iectype,force in idxs:

   420

                    if force !=None:

   421

                        c_type,unpack_func, pack_func = \

   422

                            TypeTranslator.get(iectype,

   423

                                                    (None,None,None))

   424

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

   425

                    self._RegisterDebugVariable(idx, force)

   426

                self._resumeDebug()

   427

        else:

   428

            self._suspendDebug(True)

   429

            self._Idxs =  []

   430

   431

    def GetTraceVariables(self):

   432

        """

   433

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

   434

        """

   435

        if self.PLCStatus == "Started":

   436

            res=[]

   437

            tick = ctypes.c_uint32()

   438

            size = ctypes.c_uint32()

   439

            buffer = ctypes.c_void_p()

   440

            offset = 0

   441

            if self.PLClibraryLock.acquire(False):

   442

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

   443

                                      ctypes.byref(size),

   444

                                      ctypes.byref(buffer)) == 0:

   445

                    if size.value:

   446

                        for idx, iectype, forced in self._Idxs:

   447

                            cursor = ctypes.c_void_p(buffer.value + offset)

   448

                            c_type,unpack_func, pack_func = \

   449

                                TypeTranslator.get(iectype,

   450

                                                        (None,None,None))

   451

                            if c_type is not None and offset < size.value:

   452

                                res.append(unpack_func(

   453

                                            ctypes.cast(cursor,

   454

                                             ctypes.POINTER(c_type)).contents))

   455

                                offset += ctypes.sizeof(c_type)

   456

                            else:

   457

                                if c_type is None:

   458

                                    PLCprint("Debug error - " + iectype +

   459

                                             " not supported !")

   460

                                #if offset >= size.value:

   461

                                    #PLCprint("Debug error - buffer too small ! %d != %d"%(offset, size.value))

   462

                                break

   463

                    self._FreeDebugData()

   464

                self.PLClibraryLock.release()

   465

            if offset and offset == size.value:

   466

                return self.PLCStatus, tick.value, res

   467

            #elif size.value:

   468

                #PLCprint("Debug error - wrong buffer unpack ! %d != %d"%(offset, size.value))

   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