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

    38

lib_ext ={

    39

     "linux2":".so",

    40

     "win32":".dll",

    41

     }.get(sys.platform, "")

    42

    43

def PLCprint(message):

    44

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

    45

    sys.stdout.flush()

    46

    47

class PLCObject(pyro.ObjBase):

    48

    _Idxs = []

    49

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

    50

        pyro.ObjBase.__init__(self)

    51

        self.evaluator = evaluator

    52

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

    53

        self.workingdir = workingdir

    54

        self.PLCStatus = "Stopped"

    55

        self.PLClibraryHandle = None

    56

        self.PLClibraryLock = Lock()

    57

        self.DummyIteratorLock = None

    58

        # Creates fake C funcs proxies

    59

        self._FreePLC()

    60

        self.daemon = daemon

    61

        self.statuschange = statuschange

    62

        self.hmi_frame = None

    63

        self.website = website

    64

    65

        # Get the last transfered PLC if connector must be restart

    66

        try:

    67

            self.CurrentPLCFilename=open(

    68

                             self._GetMD5FileName(),

    69

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

    70

        except Exception, e:

    71

            self.PLCStatus = "Empty"

    72

            self.CurrentPLCFilename=None

    73

    74

    def StatusChange(self):

    75

        if self.statuschange is not None:

    76

            self.statuschange(self.PLCStatus)

    77

    78

    def _GetMD5FileName(self):

    79

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

    80

    81

    def _GetLibFileName(self):

    82

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

    83

    84

    85

    def _LoadNewPLC(self):

    86

        """

    87

        Load PLC library

    88

        Declare all functions, arguments and return values

    89

        """

    90

        try:

    91

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

    92

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

    93

    94

            self._startPLC = self.PLClibraryHandle.startPLC

    95

            self._startPLC.restype = ctypes.c_int

    96

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

    97

    98

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

    99

            self._stopPLC_real.restype = None

   100

   101

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

   102

            if self._PythonIterator is not None:

   103

                self._PythonIterator.restype = ctypes.c_char_p

   104

                self._PythonIterator.argtypes = [ctypes.c_char_p]

   105

   106

                self._stopPLC = self._stopPLC_real

   107

            else:

   108

                # If python plugin is not enabled, we reuse _PythonIterator

   109

                # as a call that block pythonthread until StopPLC 

   110

                self.PythonIteratorLock = Lock()

   111

                self.PythonIteratorLock.acquire()

   112

                def PythonIterator(res):

   113

                    self.PythonIteratorLock.acquire()

   114

                    self.PythonIteratorLock.release()

   115

                    return None

   116

                self._PythonIterator = PythonIterator

   117

   118

                def __StopPLC():

   119

                    self._stopPLC_real()

   120

                    self.PythonIteratorLock.release()

   121

                self._stopPLC = __StopPLC

   122

   123

   124

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   125

            self._ResetDebugVariables.restype = None

   126

   127

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   128

            self._RegisterDebugVariable.restype = None

   129

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

   130

   131

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   132

            self._FreeDebugData.restype = None

   133

   134

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   135

            self._GetDebugData.restype = ctypes.c_int  

   136

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

   137

   138

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   139

            self._suspendDebug.restype = ctypes.c_int

   140

            self._suspendDebug.argtypes = [ctypes.c_int]

   141

   142

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   143

            self._resumeDebug.restype = None

   144

   145

            return True

   146

        except:

   147

            PLCprint(traceback.format_exc())

   148

            return False

   149

   150

    def _FreePLC(self):

   151

        """

   152

        Unload PLC library.

   153

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

   154

        """

   155

        self.PLClibraryLock.acquire()

   156

        # Forget all refs to library

   157

        self._startPLC = lambda:None

   158

        self._stopPLC = lambda:None

   159

        self._ResetDebugVariables = lambda:None

   160

        self._RegisterDebugVariable = lambda x, y:None

   161

        self._IterDebugData = lambda x,y:None

   162

        self._FreeDebugData = lambda:None

   163

        self._GetDebugData = lambda:-1

   164

        self._suspendDebug = lambda x:-1

   165

        self._resumeDebug = lambda:None

   166

        self._PythonIterator = lambda:""

   167

        self.PLClibraryHandle = None

   168

        # Unload library explicitely

   169

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

   170

            dlclose(self._PLClibraryHandle)

   171

            self._PLClibraryHandle = None

   172

   173

        self.PLClibraryLock.release()

   174

        return False

   175

   176

    def PrepareRuntimePy(self):

   177

        self.python_threads_vars = globals().copy()

   178

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

   179

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

   180

        self.python_threads_vars["_runtime_begin"] = []

   181

        self.python_threads_vars["_runtime_cleanup"] = []

   182

   183

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

   184

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

   185

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

   186

                try:

   187

                    # TODO handle exceptions in runtime.py

   188

                    # pyfile may redefine _runtime_cleanup

   189

                    # or even call _PythonThreadProc itself.

   190

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

   191

                except:

   192

                    PLCprint(traceback.format_exc())

   193

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

   194

                if runtime_begin is not None:

   195

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

   196

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

   197

                if runtime_cleanup is not None:

   198

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

   199

   200

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

   201

            runtime_begin()

   202

   203

        if self.website is not None:

   204

            self.website.PLCStarted()

   205

   206

    def FinishRuntimePy(self):

   207

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

   208

            runtime_cleanup()    

   209

        if self.website is not None:

   210

            self.website.PLCStopped()

   211

        self.python_threads_vars = None

   212

   213

    def PythonThreadProc(self):

   214

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

   215

        error = None

   216

        if self._LoadNewPLC():

   217

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

   218

                self.PLCStatus = "Started"

   219

                self.StatusChange()

   220

                self.StartSem.release()

   221

                self.evaluator(self.PrepareRuntimePy)

   222

                res,cmd = "None","None"

   223

                while True:

   224

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

   225

                    cmd = self._PythonIterator(res)

   226

                    #print " -> ", cmd

   227

                    if cmd is None:

   228

                        break

   229

                    try :

   230

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

   231

                    except Exception,e:

   232

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

   233

                        PLCprint(res)

   234

                self.PLCStatus = "Stopped"

   235

                self.StatusChange()

   236

                self.evaluator(self.FinishRuntimePy)

   237

            else:

   238

                error = "starting"

   239

        else:

   240

            error = "loading"

   241

        if error is not None:

   242

            PLCprint("Problem %s PLC"%error)

   243

            self.PLCStatus = "Broken"

   244

            self.StatusChange()

   245

            self.StartSem.release()

   246

        self._FreePLC()

   247

   248

    def StartPLC(self):

   249

        PLCprint("StartPLC")

   250

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

   251

            self.StartSem=Semaphore(0)

   252

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

   253

            self.PythonThread.start()

   254

            self.StartSem.acquire()

   255

   256

    def StopPLC(self):

   257

        PLCprint("StopPLC")

   258

        if self.PLCStatus == "Started":

   259

            self.PLCStatus = "Stopped"

   260

            self._stopPLC()

   261

            return True

   262

        return False

   263

   264

    def _Reload(self):

   265

        self.daemon.shutdown(True)

   266

        self.daemon.sock.close()

   267

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

   268

        # never reached

   269

        return 0

   270

   271

    def ForceReload(self):

   272

        # respawn python interpreter

   273

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

   274

        return True

   275

   276

    def GetPLCstatus(self):

   277

        return self.PLCStatus

   278

   279

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

   280

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

   281

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

   282

            NewFileName = md5sum + lib_ext

   283

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

   284

            try:

   285

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

   286

                                       self.CurrentPLCFilename))

   287

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

   288

                    try:

   289

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

   290

                    except:

   291

                        pass

   292

            except:

   293

                pass

   294

   295

            try:

   296

                # Create new PLC file

   297

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

   298

                     'wb').write(data)

   299

   300

                # Store new PLC filename based on md5 key

   301

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

   302

   303

                # Then write the files

   304

                log = file(extra_files_log, "w")

   305

                for fname,fdata in extrafiles:

   306

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

   307

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

   308

                    log.write(fname+'\n')

   309

   310

                # Store new PLC filename

   311

                self.CurrentPLCFilename = NewFileName

   312

            except:

   313

                PLCprint(traceback.format_exc())

   314

                return False

   315

            if self.PLCStatus == "Empty":

   316

                self.PLCStatus = "Stopped"

   317

            return True

   318

        return False

   319

   320

    def MatchMD5(self, MD5):

   321

        try:

   322

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

   323

            return last_md5 == MD5

   324

        except:

   325

            return False

   326

   327

   328

   329

    def SetTraceVariablesList(self, idxs):

   330

        """

   331

        Call ctype imported function to append 

   332

        these indexes to registred variables in PLC debugger

   333

        """

   334

        if idxs:

   335

            # suspend but dont disable

   336

            if self._suspendDebug(False) == 0:

   337

                # keep a copy of requested idx

   338

                self._Idxs = idxs[:]

   339

                self._ResetDebugVariables()

   340

                for idx,iectype,force in idxs:

   341

                    if force !=None:

   342

                        c_type,unpack_func, pack_func = \

   343

                            TypeTranslator.get(iectype,

   344

                                                    (None,None,None))

   345

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

   346

                    self._RegisterDebugVariable(idx, force)

   347

                self._resumeDebug()

   348

        else:

   349

            self._suspendDebug(True)

   350

            self._Idxs =  []

   351

   352

    def GetTraceVariables(self):

   353

        """

   354

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

   355

        """

   356

        if self.PLCStatus == "Started":

   357

            res=[]

   358

            tick = ctypes.c_uint32()

   359

            size = ctypes.c_uint32()

   360

            buffer = ctypes.c_void_p()

   361

            offset = 0

   362

            if self.PLClibraryLock.acquire(False) and \

   363

               self._GetDebugData(ctypes.byref(tick),

   364

                                  ctypes.byref(size),

   365

                                  ctypes.byref(buffer)) == 0 :

   366

                if size.value:

   367

                    for idx, iectype, forced in self._Idxs:

   368

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

   369

                        c_type,unpack_func, pack_func = \

   370

                            TypeTranslator.get(iectype,

   371

                                                    (None,None,None))

   372

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

   373

                            res.append(unpack_func(

   374

                                        ctypes.cast(cursor,

   375

                                         ctypes.POINTER(c_type)).contents))

   376

                            offset += ctypes.sizeof(c_type)

   377

                        else:

   378

                            if c_type is None:

   379

                                PLCprint("Debug error - " + iectype +

   380

                                         " not supported !")

   381

                            #if offset >= size.value:

   382

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

   383

                            break

   384

                self._FreeDebugData()

   385

                self.PLClibraryLock.release()

   386

            if offset and offset == size.value:

   387

                return self.PLCStatus, tick.value, res

   388

            #elif size.value:

   389

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

   390

        return self.PLCStatus, None, []

   391