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

    27

import ctypes, os, commands, types, sys

    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

    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):

    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

        # Creates fake C funcs proxies

    57

        self._FreePLC()

    58

        self.daemon = daemon

    59

        self.statuschange = statuschange

    60

        self.hmi_frame = None

    61

    62

        # Get the last transfered PLC if connector must be restart

    63

        try:

    64

            self.CurrentPLCFilename=open(

    65

                             self._GetMD5FileName(),

    66

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

    67

        except Exception, e:

    68

            self.PLCStatus = "Empty"

    69

            self.CurrentPLCFilename=None

    70

    71

    def StatusChange(self):

    72

        if self.statuschange is not None:

    73

            self.statuschange(self.PLCStatus)

    74

    75

    def _GetMD5FileName(self):

    76

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

    77

    78

    def _GetLibFileName(self):

    79

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

    80

    81

    82

    def _LoadNewPLC(self):

    83

        """

    84

        Load PLC library

    85

        Declare all functions, arguments and return values

    86

        """

    87

        PLCprint("Load PLC")

    88

        try:

    89

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

    90

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

    91

    92

            self._startPLC = self.PLClibraryHandle.startPLC

    93

            self._startPLC.restype = ctypes.c_int

    94

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

    95

    96

            self._stopPLC = self.PLClibraryHandle.stopPLC

    97

            self._stopPLC.restype = None

    98

    99

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   100

            self._ResetDebugVariables.restype = None

   101

   102

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   103

            self._RegisterDebugVariable.restype = None

   104

            self._RegisterDebugVariable.argtypes = [ctypes.c_int]

   105

   106

            self._IterDebugData = self.PLClibraryHandle.IterDebugData

   107

            self._IterDebugData.restype = ctypes.c_void_p

   108

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

   109

   110

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   111

            self._FreeDebugData.restype = None

   112

   113

            self._WaitDebugData = self.PLClibraryHandle.WaitDebugData

   114

            self._WaitDebugData.restype = ctypes.c_int  

   115

   116

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   117

            self._suspendDebug.restype = None

   118

   119

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   120

            self._resumeDebug.restype = None

   121

   122

            self._PythonIterator = self.PLClibraryHandle.PythonIterator

   123

            self._PythonIterator.restype = ctypes.c_char_p

   124

            self._PythonIterator.argtypes = [ctypes.c_char_p]

   125

   126

            return True

   127

        except:

   128

            PLCprint(traceback.format_exc())

   129

            return False

   130

   131

    def _FreePLC(self):

   132

        """

   133

        Unload PLC library.

   134

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

   135

        """

   136

        # Forget all refs to library

   137

        self._startPLC = lambda:None

   138

        self._stopPLC = lambda:None

   139

        self._ResetDebugVariables = lambda:None

   140

        self._RegisterDebugVariable = lambda x:None

   141

        self._IterDebugData = lambda x,y:None

   142

        self._FreeDebugData = lambda:None

   143

        self._WaitDebugData = lambda:-1

   144

        self._suspendDebug = lambda:None

   145

        self._resumeDebug = lambda:None

   146

        self._PythonIterator = lambda:""

   147

        self.PLClibraryHandle = None

   148

        # Unload library explicitely

   149

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

   150

            PLCprint("Unload PLC")

   151

            dlclose(self._PLClibraryHandle)

   152

            res = self._DetectDirtyLibs()

   153

        else:

   154

            res = False

   155

   156

        self._PLClibraryHandle = None

   157

   158

        return res

   159

   160

    def _DetectDirtyLibs(self):

   161

        # Detect dirty libs

   162

        # Get lib dependencies (for dirty lib detection)

   163

        if os.name == "posix":

   164

            # parasiting libs listed with ldd

   165

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

   166

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

   167

            for badlib in badlibs:

   168

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

   169

                                  "libwxs",

   170

                                  "libgtk",

   171

                                  "libgdk",

   172

                                  "libatk",

   173

                                  "libpan",

   174

                                  "libX11",

   175

                                  ]:

   176

                    #badhandle = dlopen(badlib, dl.RTLD_NOLOAD)

   177

                    PLCprint("Dirty lib detected :" + badlib)

   178

                    #dlclose(badhandle)

   179

                    return True

   180

        return False

   181

   182

    def PrepareRuntimePy(self):

   183

        self.python_threads_vars = globals().copy()

   185

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

   186

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

   187

        if os.path.exists(hmifile):

   188

            try:

   189

                execfile(hmifile, self.python_threads_vars)

   190

                if os.path.exists(pyfile):

   191

                    try:

   192

                        # TODO handle exceptions in runtime.py

   193

                        # pyfile may redefine _runtime_cleanup

   194

                        # or even call _PythonThreadProc itself.

   195

                        execfile(pyfile, self.python_threads_vars)

   196

                    except:

   197

                        PLCprint(traceback.format_exc())

   198

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

   199

                    wx = self.python_threads_vars['wx']

   200

                    # try to instanciate the first frame found.

   201

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

   202

                        # obj is a class

   203

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

   204

                            def create_frame():

   205

                                self.hmi_frame = obj(None)

   206

                                self.python_threads_vars[name] = self.hmi_frame

   207

                                # keep track of class... never know

   208

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

   209

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

   210

                                self.hmi_frame.Show()

   211

   212

                            def OnCloseFrame(evt):

   213

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

   214

                            create_frame()

   215

                            break

   216

            except:

   217

                PLCprint(traceback.format_exc())

   218

        elif os.path.exists(pyfile):

   219

            try:

   220

                # TODO handle exceptions in runtime.py

   221

                # pyfile may redefine _runtime_cleanup

   222

                # or even call _PythonThreadProc itself.

   223

                execfile(pyfile, self.python_threads_vars)

   224

            except:

   225

                PLCprint(traceback.format_exc())

   226

        runtime_begin = self.python_threads_vars.get("_runtime_begin",None)

   227

        if runtime_begin is not None:

   228

            runtime_begin()

   229

   230

    def FinishRuntimePy(self):

   231

        runtime_cleanup = None

   232

        if self.python_threads_vars is not None:

   233

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

   234

        if runtime_cleanup is not None:

   235

            runtime_cleanup()

   236

        if self.hmi_frame is not None:

   237

            self.hmi_frame.Destroy()

   238

        self.python_threads_vars = None

   239

   240

    def PythonThreadProc(self):

   241

        PLCprint("PythonThreadProc started")

   242

        self.evaluator(self.PrepareRuntimePy)

   243

        res,cmd = "None","None"

   244

        while self.PLCStatus == "Started":

   245

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

   246

            cmd = self._PythonIterator(res)

   247

            #print " -> ", cmd

   248

            if cmd is None:

   249

                break

   250

            try :

   251

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

   252

            except Exception,e:

   253

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

   254

                PLCprint(res)

   255

        self.evaluator(self.FinishRuntimePy)

   256

        PLCprint("PythonThreadProc interrupted")

   257

   258

    def StartPLC(self, debug=False):

   259

        PLCprint("StartPLC")

   260

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

   261

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

   262

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

   263

                if debug:

   264

                    for idx in self._Idxs:

   265

                        self._RegisterDebugVariable(idx)

   266

                    self._resumeDebug()

   267

                self.PLCStatus = "Started"

   268

                self.StatusChange()

   269

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

   270

                self.PythonThread.start()

   271

                return True

   272

            else:

   273

                PLCprint("Problem starting PLC")

   274

                self._DoStopPLC()

   275

        return False

   276

   277

    def _DoStopPLC(self):

   278

        self.PLCStatus = "Stopped"

   279

        self.StatusChange()

   280

        self._stopPLC()

   283

        if self._FreePLC():

   284

            self.PLCStatus = "Dirty"

   285

        self.StatusChange()

   286

        return True

   287

   288

    def StopPLC(self):

   289

        if self.PLCStatus == "Started":

   290

            self._DoStopPLC()

   291

            return True

   292

        return False

   293

   294

    def _Reload(self):

   295

        self.daemon.shutdown(True)

   296

        self.daemon.sock.close()

   297

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

   298

        # never reached

   299

        return 0

   300

   301

    def ForceReload(self):

   302

        # respawn python interpreter

   303

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

   304

        return True

   305

   306

    def GetPLCstatus(self):

   307

        return self.PLCStatus

   308

   309

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

   310

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

   311

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

   312

            NewFileName = md5sum + lib_ext

   313

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

   314

            try:

   315

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

   316

                                       self.CurrentPLCFilename))

   317

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

   318

                    try:

   319

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

   320

                    except:

   321

                        pass

   322

            except:

   323

                pass

   324

   325

            try:

   326

                # Create new PLC file

   327

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

   328

                     'wb').write(data)

   329

   330

                # Store new PLC filename based on md5 key

   331

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

   332

   333

                # Then write the files

   334

                log = file(extra_files_log, "w")

   335

                for fname,fdata in extrafiles:

   336

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

   337

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

   338

                    log.write(fname+'\n')

   339

   340

                # Store new PLC filename

   341

                self.CurrentPLCFilename = NewFileName

   342

            except:

   343

                PLCprint(traceback.format_exc())

   344

                return False

   345

            if self.PLCStatus == "Empty":

   346

                self.PLCStatus = "Stopped"

   347

            return True

   348

        return False

   349

   350

    def MatchMD5(self, MD5):

   351

        try:

   352

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

   353

            return last_md5 == MD5

   354

        except:

   355

            return False

   356

   357

    def SetTraceVariablesList(self, idxs):

   358

        """

   359

        Call ctype imported function to append 

   360

        these indexes to registred variables in PLC debugger

   361

        """

   362

        self._suspendDebug()

   363

        # keep a copy of requested idx

   364

        self._Idxs = idxs[:]

   365

        self._ResetDebugVariables()

   366

        for idx in idxs:

   367

            self._RegisterDebugVariable(idx)

   368

        self._resumeDebug()

   369

   370

    class IEC_STRING(ctypes.Structure):

   371

        """

   372

        Must be changed according to changes in iec_types.h

   373

        """

   374

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

   375

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

   376

   377

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

   378

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

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

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

   386

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

   387

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

   388

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

   389

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

   390

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

   391

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

   392

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

   393

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

   394

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

   395

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

   396

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

   397

                      } 

   398

   399

    def GetTraceVariables(self):

   400

        """

   401

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

   402

        """

   403

        if self.PLCStatus == "Started":

   404

            tick = self._WaitDebugData()

   405

            if tick == -1:

   406

                res = None

   407

            else:

   408

                idx = ctypes.c_int()

   409

                typename = ctypes.c_char_p()

   410

                res = []

   411

   412

                for given_idx in self._Idxs:

   413

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

   414

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

   415

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

   416

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

   417

                                                           ctypes.POINTER(c_type)).contents))

   418

                    else:

   419

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

   420

                        res.append(None)

   422

            self._FreeDebugData()

   423

            return tick, res

   424

        return -1, None

   425

   426

   427