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

        self.python_threads_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 _LoadNewPLC(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

            return True

   200

        except:

   201

            self._loading_error = traceback.format_exc()

   202

            PLCprint(self._loading_error)

   203

            return False

   204

   205

    def _FreePLC(self):

   206

        """

   207

        Unload PLC library.

   208

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

   209

        """

   210

        self.PLClibraryLock.acquire()

   211

        # Forget all refs to library

   212

        self._startPLC = lambda:None

   213

        self._stopPLC = lambda:None

   214

        self._ResetDebugVariables = lambda:None

   215

        self._RegisterDebugVariable = lambda x, y:None

   216

        self._IterDebugData = lambda x,y:None

   217

        self._FreeDebugData = lambda:None

   218

        self._GetDebugData = lambda:-1

   219

        self._suspendDebug = lambda x:-1

   220

        self._resumeDebug = lambda:None

   221

        self._PythonIterator = lambda:""

   222

        self._GetLogCount = None 

   223

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

   224

        self._GetLogMessage = None

   225

        self.PLClibraryHandle = None

   226

        # Unload library explicitely

   227

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

   228

            dlclose(self._PLClibraryHandle)

   229

            self._PLClibraryHandle = None

   230

   231

        self.PLClibraryLock.release()

   232

        return False

   233

   234

    def PrepareRuntimePy(self):

   235

        self.python_threads_vars = globals().copy()

   236

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

   237

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

   238

        self.python_threads_vars["_runtime_begin"] = []

   239

        self.python_threads_vars["_runtime_cleanup"] = []

   240

        self.python_threads_vars["PLCObject"] = self

   241

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

   242

   243

        try:

   244

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

   245

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

   246

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

   247

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

   248

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

   249

                    if runtime_begin is not None:

   250

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

   251

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

   252

                    if runtime_cleanup is not None:

   253

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

   254

   255

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

   256

                runtime_begin()

   257

        except:

   258

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

   259

            raise

   260

   261

        if self.website is not None:

   262

            self.website.PLCStarted()

   263

   264

    def FinishRuntimePy(self):

   265

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

   266

            runtime_cleanup()    

   267

        if self.website is not None:

   268

            self.website.PLCStopped()

   269

        self.python_threads_vars = None

   270

   271

    def PythonThreadProc(self):

   272

        self.PLCStatus = "Started"

   273

        self.StatusChange()

   274

        self.StartSem.release()

   275

        res,exp = self.evaluator(self.PrepareRuntimePy)

   276

        if exp is not None: raise(exp)

   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

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

   301

        self.PLCStatus = "Stopped"

   302

        self.StatusChange()

   303

        exp,res = self.evaluator(self.FinishRuntimePy)

   304

        if exp is not None: raise(exp)

   305

   306

    def StartPLC(self):

   307

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

   308

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

   309

            error = None

   310

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

   311

            if res == 0:

   312

                self.StartSem=Semaphore(0)

   313

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

   314

                self.PythonThread.start()

   315

                self.StartSem.acquire()

   316

                self.LogMessage("PLC started")

   317

            else:

   318

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

   319

                self.PLCStatus = "Broken"

   320

                self.StatusChange()

   321

   322

    def StopPLC(self):

   323

        if self.PLCStatus == "Started":

   324

            self.LogMessage("PLC stopped")

   325

            self._stopPLC()

   326

            self.PythonThread.join()

   327

            return True

   328

        return False

   329

   330

    def _Reload(self):

   331

        self.daemon.shutdown(True)

   332

        self.daemon.sock.close()

   333

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

   334

        # never reached

   335

        return 0

   336

   337

    def ForceReload(self):

   338

        # respawn python interpreter

   339

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

   340

        return True

   341

   342

    def GetPLCstatus(self):

   343

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

   344

   345

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

   346

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

   347

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

   348

            NewFileName = md5sum + lib_ext

   349

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

   350

   351

            self._FreePLC()

   352

            self.PLCStatus = "Empty"

   353

   354

            try:

   355

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

   356

                                       self.CurrentPLCFilename))

   357

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

   358

                    try:

   359

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

   360

                    except:

   361

                        pass

   362

            except:

   363

                pass

   364

   365

            try:

   366

                # Create new PLC file

   367

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

   368

                     'wb').write(data)

   369

   370

                # Store new PLC filename based on md5 key

   371

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

   372

   373

                # Then write the files

   374

                log = file(extra_files_log, "w")

   375

                for fname,fdata in extrafiles:

   376

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

   377

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

   378

                    log.write(fname+'\n')

   379

   380

                # Store new PLC filename

   381

                self.CurrentPLCFilename = NewFileName

   382

            except:

   383

                self.PLCStatus = "Broken"

   384

                self.StatusChange()

   385

                PLCprint(traceback.format_exc())

   386

                return False

   387

   388

            if self._LoadNewPLC():

   389

                self.PLCStatus = "Stopped"

   390

            else:

   391

                self._FreePLC()

   392

            self.StatusChange()

   393

   394

            return self.PLCStatus == "Stopped"

   395

        return False

   396

   397

    def MatchMD5(self, MD5):

   398

        try:

   399

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

   400

            return last_md5 == MD5

   401

        except:

   402

            return False

   403

   404

   405

   406

    def SetTraceVariablesList(self, idxs):

   407

        """

   408

        Call ctype imported function to append 

   409

        these indexes to registred variables in PLC debugger

   410

        """

   411

        if idxs:

   412

            # suspend but dont disable

   413

            if self._suspendDebug(False) == 0:

   414

                # keep a copy of requested idx

   415

                self._Idxs = idxs[:]

   416

                self._ResetDebugVariables()

   417

                for idx,iectype,force in idxs:

   418

                    if force !=None:

   419

                        c_type,unpack_func, pack_func = \

   420

                            TypeTranslator.get(iectype,

   421

                                                    (None,None,None))

   422

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

   423

                    self._RegisterDebugVariable(idx, force)

   424

                self._resumeDebug()

   425

        else:

   426

            self._suspendDebug(True)

   427

            self._Idxs =  []

   428

   429

    def GetTraceVariables(self):

   430

        """

   431

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

   432

        """

   433

        if self.PLCStatus == "Started":

   434

            res=[]

   435

            tick = ctypes.c_uint32()

   436

            size = ctypes.c_uint32()

   437

            buffer = ctypes.c_void_p()

   438

            offset = 0

   439

            if self.PLClibraryLock.acquire(False):

   440

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

   441

                                      ctypes.byref(size),

   442

                                      ctypes.byref(buffer)) == 0:

   443

                    if size.value:

   444

                        for idx, iectype, forced in self._Idxs:

   445

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

   446

                            c_type,unpack_func, pack_func = \

   447

                                TypeTranslator.get(iectype,

   448

                                                        (None,None,None))

   449

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

   450

                                res.append(unpack_func(

   451

                                            ctypes.cast(cursor,

   452

                                             ctypes.POINTER(c_type)).contents))

   453

                                offset += ctypes.sizeof(c_type)

   454

                            else:

   455

                                if c_type is None:

   456

                                    PLCprint("Debug error - " + iectype +

   457

                                             " not supported !")

   458

                                #if offset >= size.value:

   459

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

   460

                                break

   461

                    self._FreeDebugData()

   462

                self.PLClibraryLock.release()

   463

            if offset and offset == size.value:

   464

                return self.PLCStatus, tick.value, res

   465

            #elif size.value:

   466

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

   467

        return self.PLCStatus, None, []

   468

   469

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

   470

        try:

   471

            exec script in kwargs

   472

        except:

   473

            e_type, e_value, e_traceback = sys.exc_info()

   474

            line_no = traceback.tb_lineno(get_last_traceback(e_traceback))

   475

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

   476

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

   477

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

   478

   479