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

    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

        self.website = website

    63

    64

        # Get the last transfered PLC if connector must be restart

    65

        try:

    66

            self.CurrentPLCFilename=open(

    67

                             self._GetMD5FileName(),

    68

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

    69

        except Exception, e:

    70

            self.PLCStatus = "Empty"

    71

            self.CurrentPLCFilename=None

    72

    73

    def StatusChange(self):

    74

        if self.statuschange is not None:

    75

            self.statuschange(self.PLCStatus)

    76

    77

    def _GetMD5FileName(self):

    78

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

    79

    80

    def _GetLibFileName(self):

    81

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

    82

    83

    84

    def _LoadNewPLC(self):

    85

        """

    86

        Load PLC library

    87

        Declare all functions, arguments and return values

    88

        """

    89

        PLCprint("Load PLC")

    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

                def StopPLCLock():

   107

                    self.PLClibraryLock.acquire()

   108

                    self._stopPLC_real()

   109

                    self.PLClibraryLock.release()

   110

   111

            else:

   112

                # If python plugin 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 StopPLCLock():

   123

                    self.PLClibraryLock.acquire()

   124

                    self._stopPLC_real()

   125

                    self.PythonIteratorLock.release()

   126

                    self.PLClibraryLock.release()

   127

   128

            self._stopPLC = StopPLCLock

   129

   130

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   131

            self._ResetDebugVariables.restype = None

   132

   133

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   134

            self._RegisterDebugVariable.restype = None

   135

            self._RegisterDebugVariable.argtypes = [ctypes.c_int]

   136

   137

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   138

            self._FreeDebugData.restype = None

   139

   140

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   141

            self._GetDebugData.restype = ctypes.c_int  

   142

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

   143

   144

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   145

            self._suspendDebug.restype = None

   146

            self._suspendDebug.argtypes = [ctypes.c_int]

   147

   148

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   149

            self._resumeDebug.restype = None

   150

   151

            return True

   152

        except:

   153

            PLCprint(traceback.format_exc())

   154

            return False

   155

   156

    def _FreePLC(self):

   157

        """

   158

        Unload PLC library.

   159

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

   160

        """

   161

        self.PLClibraryLock.acquire()

   162

        # Forget all refs to library

   163

        self._startPLC = lambda:None

   164

        self._stopPLC = lambda:None

   165

        self._ResetDebugVariables = lambda:None

   166

        self._RegisterDebugVariable = lambda x:None

   167

        self._IterDebugData = lambda x,y:None

   168

        self._FreeDebugData = lambda:None

   169

        self._GetDebugData = lambda:-1

   170

        self._suspendDebug = lambda:None

   171

        self._resumeDebug = lambda:None

   172

        self._PythonIterator = lambda:""

   173

        self.PLClibraryHandle = None

   174

        # Unload library explicitely

   175

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

   176

            dlclose(self._PLClibraryHandle)

   177

            self._PLClibraryHandle = None

   178

   179

        self.PLClibraryLock.release()

   180

        return False

   181

   182

    def PrepareRuntimePy(self):

   183

        self.python_threads_vars = globals().copy()

   184

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

   185

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

   186

        self.python_threads_vars["_runtime_begin"] = []

   187

        self.python_threads_vars["_runtime_cleanup"] = []

   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

        PLCprint("PythonThreadProc started")

   221

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

   222

        error = None

   223

        if self._LoadNewPLC():

   224

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

   225

                self.PLCStatus = "Started"

   226

                self.StatusChange()

   227

                self.evaluator(self.PrepareRuntimePy)

   228

                res,cmd = "None","None"

   229

                while True:

   230

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

   231

                    cmd = self._PythonIterator(res)

   232

                    #print " -> ", cmd

   233

                    if cmd is None:

   234

                        break

   235

                    try :

   236

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

   237

                    except Exception,e:

   238

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

   239

                        PLCprint(res)

   240

                self.PLCStatus = "Stopped"

   241

                self.StatusChange()

   242

                self.evaluator(self.FinishRuntimePy)

   243

            else:

   244

                error = "starting"

   245

        else:

   246

            error = "loading"

   247

        if error is not None:

   248

            PLCprint("Problem %s PLC"%error)

   249

            self.PLCStatus = "Broken"

   250

        self._FreePLC()

   251

        PLCprint("PythonThreadProc interrupted")

   252

   253

    def StartPLC(self):

   254

        PLCprint("StartPLC")

   255

        if self.CurrentPLCFilename is not None:

   256

            self.PLCStatus = "Started"

   257

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

   258

            self.PythonThread.start()

   259

   260

    def StopPLC(self):

   261

        PLCprint("StopPLC")

   262

        if self.PLCStatus == "Started":

   263

            self._stopPLC()

   264

            return True

   265

        return False

   266

   267

    def _Reload(self):

   268

        self.daemon.shutdown(True)

   269

        self.daemon.sock.close()

   270

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

   271

        # never reached

   272

        return 0

   273

   274

    def ForceReload(self):

   275

        # respawn python interpreter

   276

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

   277

        return True

   278

   279

    def GetPLCstatus(self):

   280

        return self.PLCStatus

   281

   282

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

   283

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

   284

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

   285

            NewFileName = md5sum + lib_ext

   286

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

   287

            try:

   288

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

   289

                                       self.CurrentPLCFilename))

   290

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

   291

                    try:

   292

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

   293

                    except:

   294

                        pass

   295

            except:

   296

                pass

   297

   298

            try:

   299

                # Create new PLC file

   300

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

   301

                     'wb').write(data)

   302

   303

                # Store new PLC filename based on md5 key

   304

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

   305

   306

                # Then write the files

   307

                log = file(extra_files_log, "w")

   308

                for fname,fdata in extrafiles:

   309

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

   310

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

   311

                    log.write(fname+'\n')

   312

   313

                # Store new PLC filename

   314

                self.CurrentPLCFilename = NewFileName

   315

            except:

   316

                PLCprint(traceback.format_exc())

   317

                return False

   318

            if self.PLCStatus == "Empty":

   319

                self.PLCStatus = "Stopped"

   320

            return True

   321

        return False

   322

   323

    def MatchMD5(self, MD5):

   324

        try:

   325

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

   326

            return last_md5 == MD5

   327

        except:

   328

            return False

   329

   330

    def SetTraceVariablesList(self, idxs):

   331

        """

   332

        Call ctype imported function to append 

   333

        these indexes to registred variables in PLC debugger

   334

        """

   335

        if idxs:

   336

            # suspend but dont disable

   337

            self._suspendDebug(False)

   338

            # keep a copy of requested idx

   339

            self._Idxs = idxs[:]

   340

            self._ResetDebugVariables()

   341

            for idx,iectype in idxs:

   342

                self._RegisterDebugVariable(idx)

   343

            self._resumeDebug()

   344

        else:

   345

            self._suspendDebug(True)

   346

            self._Idxs =  []

   347

   348

    class IEC_STRING(ctypes.Structure):

   349

        """

   350

        Must be changed according to changes in iec_types.h

   351

        """

   352

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

   353

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

   354

   355

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

   356

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

   357

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

   358

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

   359

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

   360

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

   361

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

   362

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

   363

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

   364

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

   365

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

   366

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

   367

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

   368

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

   369

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

   370

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

   371

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

   372

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

   373

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

   374

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

   375

                      } 

   376

   377

    def GetTraceVariables(self):

   378

        """

   379

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

   380

        """

   381

        if self.PLCStatus == "Started":

   382

            res=[]

   383

            self.PLClibraryLock.acquire()

   384

            tick = ctypes.c_uint32()

   385

            size = ctypes.c_uint32()

   386

            buffer = ctypes.c_void_p()

   387

            if self._GetDebugData(ctypes.byref(tick),ctypes.byref(size),ctypes.byref(buffer)) == 0 :

   388

                offset = 0

   389

                for idx, iectype in self._Idxs:

   390

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

   391

                    c_type,unpack_func = self.TypeTranslator.get(iectype, (None,None))

   392

                    if c_type is not None and offset < size:

   393

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

   394

                                                           ctypes.POINTER(c_type)).contents))

   395

                        offset += ctypes.sizeof(c_type)

   396

                    else:

   397

                        if c_type is None:

   398

                            PLCprint("Debug error - " + iectype + " not supported !")

   399

                        if offset >= size:

   400

                            PLCprint("Debug error - buffer too small !")

   401

                        break

   402

            self._FreeDebugData()

   403

            self.PLClibraryLock.release()

   404

            if offset == size.value:

   405

                return self.PLCStatus, tick.value, res

   406

            else:

   407

                PLCprint("Debug error - bad buffer unpack !")

   408

        return self.PLCStatus, None, None

   409