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

    27

import ctypes, os, commands, types, sys

    28

    29

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

    30

    from _ctypes import LoadLibrary as dlopen

    31

    from _ctypes import FreeLibrary as dlclose

    32

elif os.name == "posix":

    33

    from _ctypes import dlopen, dlclose

    34

    35

import traceback

    36

    37

lib_ext ={

    38

     "linux2":".so",

    39

     "win32":".dll",

    40

     }.get(sys.platform, "")

    41

    42

def PLCprint(message):

    43

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

    44

    sys.stdout.flush()

    45

    46

class PLCObject(pyro.ObjBase):

    47

    _Idxs = []

    48

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

    49

        pyro.ObjBase.__init__(self)

    50

        self.evaluator = evaluator

    51

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

    52

        self.workingdir = workingdir

    53

        self.PLCStatus = "Stopped"

    54

        self.PLClibraryHandle = None

    55

        self.PLClibraryLock = Lock()

    56

        self.DummyIteratorLock = None

    57

        # Creates fake C funcs proxies

    58

        self._FreePLC()

    59

        self.daemon = daemon

    60

        self.statuschange = statuschange

    61

        self.hmi_frame = None

    62

    63

        # Get the last transfered PLC if connector must be restart

    64

        try:

    65

            self.CurrentPLCFilename=open(

    66

                             self._GetMD5FileName(),

    67

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

    68

        except Exception, e:

    69

            self.PLCStatus = "Empty"

    70

            self.CurrentPLCFilename=None

    71

    72

    def StatusChange(self):

    73

        if self.statuschange is not None:

    74

            self.statuschange(self.PLCStatus)

    75

    76

    def _GetMD5FileName(self):

    77

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

    78

    79

    def _GetLibFileName(self):

    80

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

    81

    82

    83

    def _LoadNewPLC(self):

    84

        """

    85

        Load PLC library

    86

        Declare all functions, arguments and return values

    87

        """

    88

        PLCprint("Load PLC")

    89

        try:

    90

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

    91

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

    92

    93

            self._startPLC = self.PLClibraryHandle.startPLC

    94

            self._startPLC.restype = ctypes.c_int

    95

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

    96

    97

            self.DummyIteratorLock = Lock()

    98

            self.DummyIteratorLock.acquire()

    99

   100

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

   101

            if self._PythonIterator is not None:

   102

                self._PythonIterator.restype = ctypes.c_char_p

   103

                self._PythonIterator.argtypes = [ctypes.c_char_p]

   104

   105

                def StopPLCLock():

   106

                    self.PLClibraryLock.acquire()

   107

                    self.PLClibraryHandle.stopPLC()

   108

                    self.PLClibraryLock.release()

   109

   110

            else:

   111

                def DummyIterator(res):

   112

                    self.DummyIteratorLock.acquire()

   113

                    return None

   114

                self._PythonIterator = DummyIterator

   115

   116

                def StopPLCLock():

   117

                    self.PLClibraryLock.acquire()

   118

                    self.PLClibraryHandle.stopPLC()

   119

                    self.DummyIteratorLock.release()

   120

                    self.PLClibraryLock.release()

   121

   122

            self._stopPLC = StopPLCLock

   123

            self._stopPLC.restype = None

   124

   125

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   126

            self._ResetDebugVariables.restype = None

   127

   128

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   129

            self._RegisterDebugVariable.restype = None

   130

            self._RegisterDebugVariable.argtypes = [ctypes.c_int]

   131

   132

            self._IterDebugData = self.PLClibraryHandle.IterDebugData

   133

            self._IterDebugData.restype = ctypes.c_void_p

   134

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

   135

   136

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   137

            self._FreeDebugData.restype = None

   138

   139

            self._WaitDebugData = self.PLClibraryHandle.WaitDebugData

   140

            self._WaitDebugData.restype = ctypes.c_int  

   141

   142

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   143

            self._suspendDebug.restype = None

   144

   145

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   146

            self._resumeDebug.restype = None

   147

   148

            return True

   149

        except:

   150

            PLCprint(traceback.format_exc())

   151

            return False

   152

   153

    def _FreePLC(self):

   154

        """

   155

        Unload PLC library.

   156

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

   157

        """

   158

        self.PLClibraryLock.acquire()

   159

        # Forget all refs to library

   160

        self._startPLC = lambda:None

   161

        self._stopPLC = lambda:None

   162

        self._ResetDebugVariables = lambda:None

   163

        self._RegisterDebugVariable = lambda x:None

   164

        self._IterDebugData = lambda x,y:None

   165

        self._FreeDebugData = lambda:None

   166

        self._WaitDebugData = lambda:-1

   167

        self._suspendDebug = lambda:None

   168

        self._resumeDebug = lambda:None

   169

        self._PythonIterator = lambda:""

   170

        self.PLClibraryHandle = None

   171

        # Unload library explicitely

   172

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

   173

            PLCprint("Unload PLC")

   174

            dlclose(self._PLClibraryHandle)

   175

            res = self._DetectDirtyLibs()

   176

        else:

   177

            res = False

   178

   179

        self._PLClibraryHandle = None

   180

        self.PLClibraryLock.release()

   181

        return res

   182

   183

    def _DetectDirtyLibs(self):

   184

        # Detect dirty libs

   185

        # Get lib dependencies (for dirty lib detection)

   186

        if os.name == "posix":

   187

            # parasiting libs listed with ldd

   188

            badlibs = [ toks.split()[0] for toks in commands.getoutput(

   189

                            "ldd "+self._GetLibFileName()).splitlines() ]

   190

            for badlib in badlibs:

   191

                if badlib[:6] in ["libwx_",

   192

                                  "libwxs",

   193

                                  "libgtk",

   194

                                  "libgdk",

   195

                                  "libatk",

   196

                                  "libpan",

   197

                                  "libX11",

   198

                                  ]:

   199

                    #badhandle = dlopen(badlib, dl.RTLD_NOLOAD)

   200

                    PLCprint("Dirty lib detected :" + badlib)

   201

                    #dlclose(badhandle)

   202

                    return True

   203

        return False

   204

   205

    def PrepareRuntimePy(self):

   206

        self.python_threads_vars = globals().copy()

   207

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

   208

        self.python_threads_vars["_runtime_begin"] = []

   209

        self.python_threads_vars["_runtime_cleanup"] = []

   210

#        pyfile = os.path.join(self.workingdir, "runtime.py")

   211

#        hmifile = os.path.join(self.workingdir, "hmi.py")

   212

#        if os.path.exists(hmifile):

   213

#            try:

   214

#                execfile(hmifile, self.python_threads_vars)

   215

#                if os.path.exists(pyfile):

   216

#                    try:

   217

#                        # TODO handle exceptions in runtime.py

   218

#                        # pyfile may redefine _runtime_cleanup

   219

#                        # or even call _PythonThreadProc itself.

   220

#                        execfile(pyfile, self.python_threads_vars)

   221

#                    except:

   222

#                        PLCprint(traceback.format_exc())

   223

#                if self.python_threads_vars.has_key('wx'):

   224

#                    wx = self.python_threads_vars['wx']

   225

#                    # try to instanciate the first frame found.

   226

#                    for name, obj in self.python_threads_vars.iteritems():

   227

#                        # obj is a class

   228

#                        if type(obj)==type(type) and issubclass(obj,wx.Frame):

   229

#                            def create_frame():

   230

#                                self.hmi_frame = obj(None)

   231

#                                self.python_threads_vars[name] = self.hmi_frame

   232

#                                # keep track of class... never know

   233

#                                self.python_threads_vars['Class_'+name] = obj

   234

#                                self.hmi_frame.Bind(wx.EVT_CLOSE, OnCloseFrame)

   235

#                                self.hmi_frame.Show()

   236

#                            

   237

#                            def OnCloseFrame(evt):

   238

#                                wx.MessageBox(_("Please stop PLC to close"))

   239

#                            create_frame()

   240

#                            break

   241

#            except:

   242

#                PLCprint(traceback.format_exc())

   243

#        elif os.path.exists(pyfile):

   244

#            try:

   245

#                # TODO handle exceptions in runtime.py

   246

#                # pyfile may redefine _runtime_cleanup

   247

#                # or even call _PythonThreadProc itself.

   248

#                execfile(pyfile, self.python_threads_vars)

   249

#            except:

   250

#                PLCprint(traceback.format_exc())

   251

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

   252

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

   253

            if name.startswith("runtime") and ext == ".py":

   254

                try:

   255

                    # TODO handle exceptions in runtime.py

   256

                    # pyfile may redefine _runtime_cleanup

   257

                    # or even call _PythonThreadProc itself.

   258

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

   259

                except:

   260

                    PLCprint(traceback.format_exc())

   261

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

   262

                if runtime_begin is not None:

   263

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

   264

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

   265

                if runtime_cleanup is not None:

   266

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

   267

   268

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

   269

            runtime_begin()

   270

   271

    def FinishRuntimePy(self):

   272

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

   273

            runtime_cleanup()    

   274

#        if self.python_threads_vars is not None:

   275

#            runtime_cleanup = self.python_threads_vars.get("_runtime_cleanup",None)

   276

#        if runtime_cleanup is not None:

   277

#            runtime_cleanup()

   278

#        if self.hmi_frame is not None:

   279

#            self.hmi_frame.Destroy()

   280

        self.python_threads_vars = None

   281

   282

    def PythonThreadProc(self, debug):

   283

        PLCprint("PythonThreadProc started")

   284

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

   285

        error = None

   286

        if self._LoadNewPLC():

   287

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

   288

                if debug:

   289

                    for idx in self._Idxs:

   290

                        self._RegisterDebugVariable(idx)

   291

                    self._resumeDebug()

   292

                self.PLCStatus = "Started"

   293

                self.StatusChange()

   294

                self.evaluator(self.PrepareRuntimePy)

   295

                res,cmd = "None","None"

   296

                while True:

   297

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

   298

                    cmd = self._PythonIterator(res)

   299

                    #print " -> ", cmd

   300

                    if cmd is None:

   301

                        break

   302

                    try :

   303

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

   304

                    except Exception,e:

   305

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

   306

                        PLCprint(res)

   307

                self.PLCStatus = "Stopped"

   308

                self.StatusChange()

   309

                self.evaluator(self.FinishRuntimePy)

   310

            else:

   311

                error = "starting"

   312

        else:

   313

            error = "loading"

   314

        if error is not None:

   315

            PLCprint("Problem %s PLC"%error)

   316

            self.PLCStatus = "Broken"

   317

        self._FreePLC()

   318

        PLCprint("PythonThreadProc interrupted")

   319

   320

    def StartPLC(self, debug=False):

   321

        PLCprint("StartPLC")

   322

        if self.CurrentPLCFilename is not None:

   323

            self.PythonThread = Thread(target=self.PythonThreadProc, args=[debug])

   324

            self.PythonThread.start()

   325

   326

    def StopPLC(self):

   327

        PLCprint("StopPLC")

   328

        if self.PLCStatus == "Started":

   329

            self._stopPLC()

   330

            return True

   331

        return False

   332

   333

    def _Reload(self):

   334

        self.daemon.shutdown(True)

   335

        self.daemon.sock.close()

   336

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

   337

        # never reached

   338

        return 0

   339

   340

    def ForceReload(self):

   341

        # respawn python interpreter

   342

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

   343

        return True

   344

   345

    def GetPLCstatus(self):

   346

        return self.PLCStatus

   347

   348

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

   349

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

   350

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

   351

            NewFileName = md5sum + lib_ext

   352

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

   353

            try:

   354

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

   355

                                       self.CurrentPLCFilename))

   356

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

   357

                    try:

   358

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

   359

                    except:

   360

                        pass

   361

            except:

   362

                pass

   363

   364

            try:

   365

                # Create new PLC file

   366

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

   367

                     'wb').write(data)

   368

   369

                # Store new PLC filename based on md5 key

   370

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

   371

   372

                # Then write the files

   373

                log = file(extra_files_log, "w")

   374

                for fname,fdata in extrafiles:

   375

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

   376

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

   377

                    log.write(fname+'\n')

   378

   379

                # Store new PLC filename

   380

                self.CurrentPLCFilename = NewFileName

   381

            except:

   382

                PLCprint(traceback.format_exc())

   383

                return False

   384

            if self.PLCStatus == "Empty":

   385

                self.PLCStatus = "Stopped"

   386

            return True

   387

        return False

   388

   389

    def MatchMD5(self, MD5):

   390

        try:

   391

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

   392

            return last_md5 == MD5

   393

        except:

   394

            return False

   395

   396

    def SetTraceVariablesList(self, idxs):

   397

        """

   398

        Call ctype imported function to append 

   399

        these indexes to registred variables in PLC debugger

   400

        """

   401

        self._suspendDebug()

   402

        # keep a copy of requested idx

   403

        self._Idxs = idxs[:]

   404

        self._ResetDebugVariables()

   405

        for idx in idxs:

   406

            self._RegisterDebugVariable(idx)

   407

        self._resumeDebug()

   408

   409

    class IEC_STRING(ctypes.Structure):

   410

        """

   411

        Must be changed according to changes in iec_types.h

   412

        """

   413

        _fields_ = [("len", ctypes.c_uint8),

   414

                    ("body", ctypes.c_char * 127)] 

   415

   416

    TypeTranslator = {"BOOL" :       (ctypes.c_uint8, lambda x:x.value!=0),

   417

                      "STEP" :       (ctypes.c_uint8, lambda x:x.value),

   418

                      "TRANSITION" : (ctypes.c_uint8, lambda x:x.value),

   419

                      "ACTION" :     (ctypes.c_uint8, lambda x:x.value),

   420

                      "SINT" :       (ctypes.c_int8, lambda x:x.value),

   421

                      "USINT" :      (ctypes.c_uint8, lambda x:x.value),

   422

                      "BYTE" :       (ctypes.c_uint8, lambda x:x.value),

   423

                      "STRING" :     (IEC_STRING, lambda x:x.body[:x.len]),

   424

                      "INT" :        (ctypes.c_int16, lambda x:x.value),

   425

                      "UINT" :       (ctypes.c_uint16, lambda x:x.value),

   426

                      "WORD" :       (ctypes.c_uint16, lambda x:x.value),

   427

                      "WSTRING" :    (None, None),#TODO

   428

                      "DINT" :       (ctypes.c_int32, lambda x:x.value),

   429

                      "UDINT" :      (ctypes.c_uint32, lambda x:x.value),

   430

                      "DWORD" :      (ctypes.c_uint32, lambda x:x.value),

   431

                      "LINT" :       (ctypes.c_int64, lambda x:x.value),

   432

                      "ULINT" :      (ctypes.c_uint64, lambda x:x.value),

   433

                      "LWORD" :      (ctypes.c_uint64, lambda x:x.value),

   434

                      "REAL" :       (ctypes.c_float, lambda x:x.value),

   435

                      "LREAL" :      (ctypes.c_double, lambda x:x.value),

   436

                      } 

   437

   438

    def GetTraceVariables(self):

   439

        """

   440

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

   441

        """

   442

        if self.PLCStatus == "Started":

   443

            self.PLClibraryLock.acquire()

   444

            tick = self._WaitDebugData()

   445

            #PLCprint("Debug tick : %d"%tick)

   446

            if tick == -1:

   447

                res = None

   448

            else:

   449

                idx = ctypes.c_int()

   450

                typename = ctypes.c_char_p()

   451

                res = []

   452

   453

                for given_idx in self._Idxs:

   454

                    buffer=self._IterDebugData(ctypes.byref(idx), ctypes.byref(typename))

   455

                    c_type,unpack_func = self.TypeTranslator.get(typename.value, (None,None))

   456

                    if c_type is not None and given_idx == idx.value:

   457

                        res.append(unpack_func(ctypes.cast(buffer,

   458

                                                           ctypes.POINTER(c_type)).contents))

   459

                    else:

   460

                        PLCprint("Debug error idx : %d, expected_idx %d, type : %s"%(idx.value, given_idx,typename.value))

   461

                        res.append(None)

   462

            self._FreeDebugData()

   463

            self.PLClibraryLock.release()

   464

            return tick, res

   465

        return -1, None

   466