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:

   112

                # If python confnode is not enabled, we reuse _PythonIterator

   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

        self.python_threads_vars["PLCObject"] = self

   187

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

   188

   189

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

   190

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

   191

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

   192

                try:

   193

                    # TODO handle exceptions in runtime.py

   194

                    # pyfile may redefine _runtime_cleanup

   195

                    # or even call _PythonThreadProc itself.

   196

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

   197

                except:

   198

                    PLCprint(traceback.format_exc())

   199

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

   200

                if runtime_begin is not None:

   201

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

   202

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

   203

                if runtime_cleanup is not None:

   204

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

   205

   206

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

   207

            runtime_begin()

   208

   209

        if self.website is not None:

   210

            self.website.PLCStarted()

   211

   212

    def FinishRuntimePy(self):

   213

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

   214

            runtime_cleanup()    

   215

        if self.website is not None:

   216

            self.website.PLCStopped()

   217

        self.python_threads_vars = None

   218

   219

    def PythonThreadProc(self):

   220

        self.PLCStatus = "Started"

   221

        self.StatusChange()

   222

        self.StartSem.release()

   223

        self.evaluator(self.PrepareRuntimePy)

   224

        res,cmd = "None","None"

   225

        while True:

   226

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

   227

            cmd = self._PythonIterator(res)

   228

            #print " -> ", cmd

   229

            if cmd is None:

   230

                break

   231

            try :

   232

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

   233

            except Exception,e:

   234

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

   235

                PLCprint(res)

   236

        self.PLCStatus = "Stopped"

   237

        self.StatusChange()

   238

        self.evaluator(self.FinishRuntimePy)

   239

   240

    def StartPLC(self):

   241

        PLCprint("StartPLC")

   242

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

   243

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

   244

            error = None

   245

            if self._LoadNewPLC():

   246

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

   247

                    self.StartSem=Semaphore(0)

   248

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

   249

                    self.PythonThread.start()

   250

                    self.StartSem.acquire()

   251

                else:

   252

                    error = "starting"

   253

            else:

   254

                error = "loading"

   255

            if error is not None:

   256

                PLCprint("Problem %s PLC"%error)

   257

                self.PLCStatus = "Broken"

   258

                self.StatusChange()

   259

                self._FreePLC()

   260

   261

    def StopPLC(self):

   262

        PLCprint("StopPLC")

   263

        if self.PLCStatus == "Started":

   264

            self._stopPLC()

   265

            self.PythonThread.join()

   266

            self._FreePLC()

   267

            return True

   268

        return False

   269

   270

    def _Reload(self):

   271

        self.daemon.shutdown(True)

   272

        self.daemon.sock.close()

   273

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

   274

        # never reached

   275

        return 0

   276

   277

    def ForceReload(self):

   278

        # respawn python interpreter

   279

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

   280

        return True

   281

   282

    def GetPLCstatus(self):

   283

        return self.PLCStatus

   284

   285

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

   286

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

   287

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

   288

            NewFileName = md5sum + lib_ext

   289

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

   290

            try:

   291

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

   292

                                       self.CurrentPLCFilename))

   293

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

   294

                    try:

   295

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

   296

                    except:

   297

                        pass

   298

            except:

   299

                pass

   300

   301

            try:

   302

                # Create new PLC file

   303

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

   304

                     'wb').write(data)

   305

   306

                # Store new PLC filename based on md5 key

   307

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

   308

   309

                # Then write the files

   310

                log = file(extra_files_log, "w")

   311

                for fname,fdata in extrafiles:

   312

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

   313

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

   314

                    log.write(fname+'\n')

   315

   316

                # Store new PLC filename

   317

                self.CurrentPLCFilename = NewFileName

   318

            except:

   319

                PLCprint(traceback.format_exc())

   320

                return False

   321

            if self.PLCStatus == "Empty":

   322

                self.PLCStatus = "Stopped"

   323

            return True

   324

        return False

   325

   326

    def MatchMD5(self, MD5):

   327

        try:

   328

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

   329

            return last_md5 == MD5

   330

        except:

   331

            return False

   332

   333

   334

   335

    def SetTraceVariablesList(self, idxs):

   336

        """

   337

        Call ctype imported function to append 

   338

        these indexes to registred variables in PLC debugger

   339

        """

   340

        if idxs:

   341

            # suspend but dont disable

   342

            if self._suspendDebug(False) == 0:

   343

                # keep a copy of requested idx

   344

                self._Idxs = idxs[:]

   345

                self._ResetDebugVariables()

   346

                for idx,iectype,force in idxs:

   347

                    if force !=None:

   348

                        c_type,unpack_func, pack_func = \

   349

                            TypeTranslator.get(iectype,

   350

                                                    (None,None,None))

   351

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

   352

                    self._RegisterDebugVariable(idx, force)

   353

                self._resumeDebug()

   354

        else:

   355

            self._suspendDebug(True)

   356

            self._Idxs =  []

   357

   358

    def GetTraceVariables(self):

   359

        """

   360

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

   361

        """

   362

        if self.PLCStatus == "Started":

   363

            res=[]

   364

            tick = ctypes.c_uint32()

   365

            size = ctypes.c_uint32()

   366

            buffer = ctypes.c_void_p()

   367

            offset = 0

   368

            if self.PLClibraryLock.acquire(False):

   369

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

   370

                                      ctypes.byref(size),

   371

                                      ctypes.byref(buffer)) == 0:

   372

                    if size.value:

   373

                        for idx, iectype, forced in self._Idxs:

   374

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

   375

                            c_type,unpack_func, pack_func = \

   376

                                TypeTranslator.get(iectype,

   377

                                                        (None,None,None))

   378

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

   379

                                res.append(unpack_func(

   380

                                            ctypes.cast(cursor,

   381

                                             ctypes.POINTER(c_type)).contents))

   382

                                offset += ctypes.sizeof(c_type)

   383

                            else:

   384

                                if c_type is None:

   385

                                    PLCprint("Debug error - " + iectype +

   386

                                             " not supported !")

   387

                                #if offset >= size.value:

   388

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

   389

                                break

   390

                    self._FreeDebugData()

   391

                self.PLClibraryLock.release()

   392

            if offset and offset == size.value:

   393

                return self.PLCStatus, tick.value, res

   394

            #elif size.value:

   395

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

   396

        return self.PLCStatus, None, []

   397

   398

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

   399

        try:

   400

            exec script in kwargs

   401

        except:

   402

            e_type, e_value, e_traceback = sys.exc_info()

   403

            line_no = traceback.tb_lineno(get_last_traceback(e_traceback))

   404

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

   405

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

   406

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

   407

   408