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

    29

    30

if os.name in ("nt", "ce"):

    31

    from _ctypes import LoadLibrary as dlopen

    32

    from _ctypes import FreeLibrary as dlclose

    33

elif os.name == "posix":

    34

    from _ctypes import dlopen, dlclose

    35

    36

import traceback

    37

def get_last_traceback(tb):

    38

    while tb.tb_next:

    39

        tb = tb.tb_next

    40

    return tb

    41

    42

lib_ext ={

    43

     "linux2":".so",

    44

     "win32":".dll",

    45

     }.get(sys.platform, "")

    46

    47

def PLCprint(message):

    48

    sys.stdout.write("PLCobject : "+message+"\n")

    49

    sys.stdout.flush()

    50

    51

class PLCObject(pyro.ObjBase):

    52

    _Idxs = []

    53

    def __init__(self, workingdir, daemon, argv, statuschange, evaluator, website):

    54

        pyro.ObjBase.__init__(self)

    55

        self.evaluator = evaluator

    56

        self.argv = [workingdir] + argv # force argv[0] to be "path" to exec...

    57

        self.workingdir = workingdir

    58

        self.PLCStatus = "Stopped"

    59

        self.PLClibraryHandle = None

    60

        self.PLClibraryLock = Lock()

    61

        self.DummyIteratorLock = None

    62

        # Creates fake C funcs proxies

    63

        self._FreePLC()

    64

        self.daemon = daemon

    65

        self.statuschange = statuschange

    66

        self.hmi_frame = None

    67

        self.website = website

    68

    69

        # Get the last transfered PLC if connector must be restart

    70

        try:

    71

            self.CurrentPLCFilename=open(

    72

                             self._GetMD5FileName(),

    73

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

    74

        except Exception, e:

    75

            self.PLCStatus = "Empty"

    76

            self.CurrentPLCFilename=None

    77

    78

    def StatusChange(self):

    79

        if self.statuschange is not None:

    80

            self.statuschange(self.PLCStatus)

    81

    82

    def _GetMD5FileName(self):

    83

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

    84

    85

    def _GetLibFileName(self):

    86

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

    87

    88

    89

    def _LoadNewPLC(self):

    90

        """

    91

        Load PLC library

    92

        Declare all functions, arguments and return values

    93

        """

    94

        try:

    95

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

    96

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

    97

    98

            self._startPLC = self.PLClibraryHandle.startPLC

    99

            self._startPLC.restype = ctypes.c_int

   100

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

   101

   102

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   103

            self._stopPLC_real.restype = None

   104

   105

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

   106

            if self._PythonIterator is not None:

   107

                self._PythonIterator.restype = ctypes.c_char_p

   108

                self._PythonIterator.argtypes = [ctypes.c_char_p]

   109

   110

                self._stopPLC = self._stopPLC_real

   111

            else:

   113

                # as a call that block pythonthread until StopPLC 

   114

                self.PythonIteratorLock = Lock()

   115

                self.PythonIteratorLock.acquire()

   116

                def PythonIterator(res):

   117

                    self.PythonIteratorLock.acquire()

   118

                    self.PythonIteratorLock.release()

   119

                    return None

   120

                self._PythonIterator = PythonIterator

   121

   122

                def __StopPLC():

   123

                    self._stopPLC_real()

   124

                    self.PythonIteratorLock.release()

   125

                self._stopPLC = __StopPLC

   126

   127

   128

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   129

            self._ResetDebugVariables.restype = None

   130

   131

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   132

            self._RegisterDebugVariable.restype = None

   133

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

   134

   135

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   136

            self._FreeDebugData.restype = None

   137

   138

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   139

            self._GetDebugData.restype = ctypes.c_int  

   140

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

   141

   142

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   143

            self._suspendDebug.restype = ctypes.c_int

   144

            self._suspendDebug.argtypes = [ctypes.c_int]

   145

   146

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   147

            self._resumeDebug.restype = None

   148

   149

            return True

   150

        except:

   151

            PLCprint(traceback.format_exc())

   152

            return False

   153

   154

    def _FreePLC(self):

   155

        """

   156

        Unload PLC library.

   157

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

   158

        """

   159

        self.PLClibraryLock.acquire()

   160

        # Forget all refs to library

   161

        self._startPLC = lambda:None

   162

        self._stopPLC = lambda:None

   163

        self._ResetDebugVariables = lambda:None

   164

        self._RegisterDebugVariable = lambda x, y:None

   165

        self._IterDebugData = lambda x,y:None

   166

        self._FreeDebugData = lambda:None

   167

        self._GetDebugData = lambda:-1

   168

        self._suspendDebug = lambda x:-1

   169

        self._resumeDebug = lambda:None

   170

        self._PythonIterator = lambda:""

   171

        self.PLClibraryHandle = None

   172

        # Unload library explicitely

   173

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

   174

            dlclose(self._PLClibraryHandle)

   175

            self._PLClibraryHandle = None

   176

   177

        self.PLClibraryLock.release()

   178

        return False

   179

   180

    def PrepareRuntimePy(self):

   181

        self.python_threads_vars = globals().copy()

   182

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

   183

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

   184

        self.python_threads_vars["_runtime_begin"] = []

   185

        self.python_threads_vars["_runtime_cleanup"] = []

   186

   187

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

   188

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

   189

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

   190

                try:

   191

                    # TODO handle exceptions in runtime.py

   192

                    # pyfile may redefine _runtime_cleanup

   193

                    # or even call _PythonThreadProc itself.

   194

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

   195

                except:

   196

                    PLCprint(traceback.format_exc())

   197

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

   198

                if runtime_begin is not None:

   199

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

   200

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

   201

                if runtime_cleanup is not None:

   202

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

   203

   204

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

   205

            runtime_begin()

   206

   207

        if self.website is not None:

   208

            self.website.PLCStarted()

   209

   210

    def FinishRuntimePy(self):

   211

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

   212

            runtime_cleanup()    

   213

        if self.website is not None:

   214

            self.website.PLCStopped()

   215

        self.python_threads_vars = None

   216

   217

    def PythonThreadProc(self):

   218

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

   219

        error = None

   220

        if self._LoadNewPLC():

   221

            if self._startPLC(len(self.argv),c_argv(*self.argv)) == 0:

   222

                self.PLCStatus = "Started"

   223

                self.StatusChange()

   224

                self.StartSem.release()

   225

                self.evaluator(self.PrepareRuntimePy)

   226

                res,cmd = "None","None"

   227

                while True:

   228

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

   229

                    cmd = self._PythonIterator(res)

   230

                    #print " -> ", cmd

   231

                    if cmd is None:

   232

                        break

   233

                    try :

   234

                        res = str(self.evaluator(eval,cmd,self.python_threads_vars))

   235

                    except Exception,e:

   236

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

   237

                        PLCprint(res)

   238

                self.PLCStatus = "Stopped"

   239

                self.StatusChange()

   240

                self.evaluator(self.FinishRuntimePy)

   241

            else:

   242

                error = "starting"

   243

        else:

   244

            error = "loading"

   245

        if error is not None:

   246

            PLCprint("Problem %s PLC"%error)

   247

            self.PLCStatus = "Broken"

   248

            self.StatusChange()

   249

            self.StartSem.release()

   250

        self._FreePLC()

   251

   252

    def StartPLC(self):

   253

        PLCprint("StartPLC")

   254

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

   255

            self.StartSem=Semaphore(0)

   256

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

   257

            self.PythonThread.start()

   258

            self.StartSem.acquire()

   259

   260

    def StopPLC(self):

   261

        PLCprint("StopPLC")

   262

        if self.PLCStatus == "Started":

   263

            self.PLCStatus = "Stopped"

   264

            self._stopPLC()

   265

            return True

   266

        return False

   267

   268

    def _Reload(self):

   269

        self.daemon.shutdown(True)

   270

        self.daemon.sock.close()

   271

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

   272

        # never reached

   273

        return 0

   274

   275

    def ForceReload(self):

   276

        # respawn python interpreter

   277

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

   278

        return True

   279

   280

    def GetPLCstatus(self):

   281

        return self.PLCStatus

   282

   283

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

   284

        PLCprint("NewPLC (%s)"%md5sum)

   285

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

   286

            NewFileName = md5sum + lib_ext

   287

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

   288

            try:

   289

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

   290

                                       self.CurrentPLCFilename))

   291

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

   292

                    try:

   293

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

   294

                    except:

   295

                        pass

   296

            except:

   297

                pass

   298

   299

            try:

   300

                # Create new PLC file

   301

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

   302

                     'wb').write(data)

   303

   304

                # Store new PLC filename based on md5 key

   305

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

   306

   307

                # Then write the files

   308

                log = file(extra_files_log, "w")

   309

                for fname,fdata in extrafiles:

   310

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

   311

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

   312

                    log.write(fname+'\n')

   313

   314

                # Store new PLC filename

   315

                self.CurrentPLCFilename = NewFileName

   316

            except:

   317

                PLCprint(traceback.format_exc())

   318

                return False

   319

            if self.PLCStatus == "Empty":

   320

                self.PLCStatus = "Stopped"

   321

            return True

   322

        return False

   323

   324

    def MatchMD5(self, MD5):

   325

        try:

   326

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

   327

            return last_md5 == MD5

   328

        except:

   329

            return False

   330

   331

   332

   333

    def SetTraceVariablesList(self, idxs):

   334

        """

   335

        Call ctype imported function to append 

   336

        these indexes to registred variables in PLC debugger

   337

        """

   338

        if idxs:

   339

            # suspend but dont disable

   340

            if self._suspendDebug(False) == 0:

   341

                # keep a copy of requested idx

   342

                self._Idxs = idxs[:]

   343

                self._ResetDebugVariables()

   344

                for idx,iectype,force in idxs:

   345

                    if force !=None:

   346

                        c_type,unpack_func, pack_func = \

   347

                            TypeTranslator.get(iectype,

   348

                                                    (None,None,None))

   349

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

   350

                    self._RegisterDebugVariable(idx, force)

   351

                self._resumeDebug()

   352

        else:

   353

            self._suspendDebug(True)

   354

            self._Idxs =  []

   355

   356

    def GetTraceVariables(self):

   357

        """

   358

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

   359

        """

   360

        if self.PLCStatus == "Started":

   361

            res=[]

   362

            tick = ctypes.c_uint32()

   363

            size = ctypes.c_uint32()

   364

            buffer = ctypes.c_void_p()

   365

            offset = 0

   366

            if self.PLClibraryLock.acquire(False) and \

   367

               self._GetDebugData(ctypes.byref(tick),

   368

                                  ctypes.byref(size),

   369

                                  ctypes.byref(buffer)) == 0 :

   370

                if size.value:

   371

                    for idx, iectype, forced in self._Idxs:

   372

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

   373

                        c_type,unpack_func, pack_func = \

   374

                            TypeTranslator.get(iectype,

   375

                                                    (None,None,None))

   376

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

   377

                            res.append(unpack_func(

   378

                                        ctypes.cast(cursor,

   379

                                         ctypes.POINTER(c_type)).contents))

   380

                            offset += ctypes.sizeof(c_type)

   381

                        else:

   382

                            if c_type is None:

   383

                                PLCprint("Debug error - " + iectype +

   384

                                         " not supported !")

   385

                            #if offset >= size.value:

   386

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

   387

                            break

   388

                self._FreeDebugData()

   389

                self.PLClibraryLock.release()

   390

            if offset and offset == size.value:

   391

                return self.PLCStatus, tick.value, res

   392

            #elif size.value:

   393

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

   394

        return self.PLCStatus, None, []

   395

   396

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

   397

        try:

   398

            exec script in kwargs

   399

        except:

   400

            e_type, e_value, e_traceback = sys.exc_info()

   401

            line_no = traceback.tb_lineno(get_last_traceback(e_traceback))

   402

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

   403

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

   404

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

   405

   406