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 LogLevelsDefault, LogLevelsCount, SameEndianessTypeTranslator as TypeTranslator

    29

    30

    31

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

    32

    from _ctypes import LoadLibrary as dlopen

    33

    from _ctypes import FreeLibrary as dlclose

    34

elif os.name == "posix":

    35

    from _ctypes import dlopen, dlclose

    36

    37

import traceback

    38

def get_last_traceback(tb):

    39

    while tb.tb_next:

    40

        tb = tb.tb_next

    41

    return tb

    42

    43

lib_ext ={

    44

     "linux2":".so",

    45

     "win32":".dll",

    46

     }.get(sys.platform, "")

    47

    48

def PLCprint(message):

    49

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

    50

    sys.stdout.flush()

    51

    52

class PLCObject(pyro.ObjBase):

    53

    _Idxs = []

    54

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

    55

        pyro.ObjBase.__init__(self)

    56

        self.evaluator = evaluator

    57

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

    58

        self.workingdir = workingdir

    59

        self.PLCStatus = "Stopped"

    60

        self.PLClibraryHandle = None

    61

        self.PLClibraryLock = Lock()

    62

        self.DummyIteratorLock = None

    63

        # Creates fake C funcs proxies

    64

        self._FreePLC()

    65

        self.daemon = daemon

    66

        self.statuschange = statuschange

    67

        self.hmi_frame = None

    68

        self.website = website

    69

        self._loading_error = None

    70

        self.python_runtime_vars = None

    71

    72

        # Get the last transfered PLC if connector must be restart

    73

        try:

    74

            self.CurrentPLCFilename=open(

    75

                             self._GetMD5FileName(),

    76

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

    77

        except Exception, e:

    78

            self.PLCStatus = "Empty"

    79

            self.CurrentPLCFilename=None

    80

    81

    def StatusChange(self):

    82

        if self.statuschange is not None:

    83

            self.statuschange(self.PLCStatus)

    84

    85

    def LogMessage(self, *args):

    86

        if len(args) == 2:

    87

            level, msg = args

    88

        else:

    89

            level = LogLevelsDefault

    90

            msg, = args

    91

        return self._LogMessage(level, msg, len(msg))

    92

    93

    94

    def GetLogCount(self, level):

    95

        if self._GetLogCount is not None :

    96

            return int(self._GetLogCount(level))

    97

        elif self._loading_error is not None and level==0:

    98

            return 1;

    99

   100

    def GetLogMessage(self, level, msgid):

   101

        tick = ctypes.c_uint32()

   102

        tv_sec = ctypes.c_uint32()

   103

        tv_nsec = ctypes.c_uint32()

   104

        if self._GetLogMessage is not None:

   105

            maxsz = len(self._log_read_buffer)-1

   106

            sz = self._GetLogMessage(level, msgid, 

   107

                self._log_read_buffer, maxsz,

   108

                ctypes.byref(tick),

   109

                ctypes.byref(tv_sec),

   110

                ctypes.byref(tv_nsec))

   111

            if sz and sz <= maxsz:

   112

                self._log_read_buffer[sz] = '\x00'

   113

                return self._log_read_buffer.value,tick.value,tv_sec.value,tv_nsec.value

   114

        elif self._loading_error is not None and level==0:

   115

            return self._loading_error,0,0,0

   116

        return None

   117

   118

    def _GetMD5FileName(self):

   119

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

   120

   121

    def _GetLibFileName(self):

   122

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

   123

   124

   125

    def LoadPLC(self):

   126

        """

   127

        Load PLC library

   128

        Declare all functions, arguments and return values

   129

        """

   130

        try:

   131

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

   132

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

   133

   134

            self._startPLC = self.PLClibraryHandle.startPLC

   135

            self._startPLC.restype = ctypes.c_int

   136

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

   137

   138

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   139

            self._stopPLC_real.restype = None

   140

   141

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

   142

            if self._PythonIterator is not None:

   143

                self._PythonIterator.restype = ctypes.c_char_p

   144

                self._PythonIterator.argtypes = [ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]

   145

   146

                self._stopPLC = self._stopPLC_real

   147

            else:

   148

                # If python confnode is not enabled, we reuse _PythonIterator

   149

                # as a call that block pythonthread until StopPLC 

   150

                self.PythonIteratorLock = Lock()

   151

                self.PythonIteratorLock.acquire()

   152

                def PythonIterator(res, blkid):

   153

                    self.PythonIteratorLock.acquire()

   154

                    self.PythonIteratorLock.release()

   155

                    return None

   156

                self._PythonIterator = PythonIterator

   157

   158

                def __StopPLC():

   159

                    self._stopPLC_real()

   160

                    self.PythonIteratorLock.release()

   161

                self._stopPLC = __StopPLC

   162

   163

   164

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   165

            self._ResetDebugVariables.restype = None

   166

   167

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   168

            self._RegisterDebugVariable.restype = None

   169

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

   170

   171

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   172

            self._FreeDebugData.restype = None

   173

   174

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   175

            self._GetDebugData.restype = ctypes.c_int  

   176

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

   177

   178

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   179

            self._suspendDebug.restype = ctypes.c_int

   180

            self._suspendDebug.argtypes = [ctypes.c_int]

   181

   182

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   183

            self._resumeDebug.restype = None

   184

   185

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   186

            self._GetLogCount.restype = ctypes.c_uint32

   187

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   188

   189

            self._LogMessage = self.PLClibraryHandle.LogMessage

   190

            self._LogMessage.restype = ctypes.c_int

   191

            self._LogMessage.argtypes = [ctypes.c_uint8, ctypes.c_char_p, ctypes.c_uint32]

   192

   193

            self._log_read_buffer = ctypes.create_string_buffer(1<<14) #16K

   194

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   195

            self._GetLogMessage.restype = ctypes.c_uint32

   196

            self._GetLogMessage.argtypes = [ctypes.c_uint8, ctypes.c_uint32, ctypes.c_char_p, ctypes.c_uint32, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32)]

   197

   198

            self._loading_error = None

   199

   200

            self.PythonRuntimeInit()

   201

   202

            return True

   203

        except:

   204

            self._loading_error = traceback.format_exc()

   205

            PLCprint(self._loading_error)

   206

            return False

   207

   208

    def _FreePLC(self):

   209

        """

   210

        Unload PLC library.

   211

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

   212

        """

   213

        self.PLClibraryLock.acquire()

   214

        # Forget all refs to library

   215

        self._startPLC = lambda x,y:None

   216

        self._stopPLC = lambda:None

   217

        self._ResetDebugVariables = lambda:None

   218

        self._RegisterDebugVariable = lambda x, y:None

   219

        self._IterDebugData = lambda x,y:None

   220

        self._FreeDebugData = lambda:None

   221

        self._GetDebugData = lambda:-1

   222

        self._suspendDebug = lambda x:-1

   223

        self._resumeDebug = lambda:None

   224

        self._PythonIterator = lambda:""

   225

        self._GetLogCount = None 

   226

        self._LogMessage = lambda l,m,s:PLCprint("OFF LOG :"+m)

   227

        self._GetLogMessage = None

   228

        self.PLClibraryHandle = None

   229

        # Unload library explicitely

   230

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

   231

            dlclose(self._PLClibraryHandle)

   232

            self._PLClibraryHandle = None

   233

   234

        self.PLClibraryLock.release()

   235

        return False

   236

   237

    def PythonRuntimeCall(self, methodname):

   238

        """ 

   239

        Calls init, start, stop or cleanup method provided by 

   240

        runtime python files, loaded when new PLC uploaded

   241

        """

   242

        try :

   243

            for method in self.python_runtime_vars.get("_runtime_%s"%methodname, []):

   244

                res,exp = self.evaluator(method)

   245

                if exp is not None: raise(exp)

   246

        except:

   247

            self.LogMessage(0,traceback.format_exc())

   248

            raise

   249

   250

    def PythonRuntimeInit(self):

   251

        MethodNames = ["init", "start", "stop", "cleanup"]

   252

        self.python_runtime_vars = globals().copy()

   253

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

   254

        self.python_runtime_vars["website"] = self.website

   255

        for methodname in MethodNames :

   256

            self.python_runtime_vars["_runtime_%s"%methodname] = []

   257

        self.python_runtime_vars["PLCObject"] = self

   258

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

   259

   260

        try:

   261

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

   262

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

   263

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

   264

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

   265

                    for methodname in MethodNames: 

   266

                        method = self.python_runtime_vars.get("_%s_%s" % (name, methodname), None)

   267

                        if method is not None:

   268

                            self.python_runtime_vars["_runtime_%s"%methodname].append(method)

   269

   270

        except:

   271

            self.LogMessage(0,traceback.format_exc())

   272

            raise

   273

   274

        self.PythonRuntimeCall("init")

   275

   276

        if self.website is not None:

   277

            self.website.PLCStarted()

   278

   279

   280

    def PythonRuntimeCleanup(self):

   281

        if self.python_runtime_vars is not None:

   282

            self.PythonRuntimeCall("cleanup")

   283

   284

        if self.website is not None:

   285

            self.website.PLCStopped()

   286

   287

        self.python_runtime_vars = None

   288

   289

    def PythonThreadProc(self):

   290

        self.PLCStatus = "Started"

   291

        self.StatusChange()

   292

        self.StartSem.release()

   293

        self.PythonRuntimeCall("start")

   294

        res,cmd,blkid = "None","None",ctypes.c_void_p()

   295

        compile_cache={}

   296

        while True:

   297

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

   298

            cmd = self._PythonIterator(res,blkid)

   299

            FBID = blkid.value 

   300

            # print " -> ", cmd, blkid

   301

            if cmd is None:

   302

                break

   303

            try :

   304

                self.python_runtime_vars["FBID"]=FBID

   305

                ccmd,AST =compile_cache.get(FBID, (None,None))

   306

                if ccmd is None or ccmd!=cmd:

   307

                    AST = compile(cmd, '<plc>', 'eval')

   308

                    compile_cache[FBID]=(cmd,AST)

   309

                result,exp = self.evaluator(eval,cmd,self.python_runtime_vars)

   310

                if exp is not None: 

   311

                    raise(exp)

   312

                else:

   313

                    res=str(result)

   314

                self.python_runtime_vars["FBID"]=None

   315

            except Exception,e:

   316

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

   317

                self.LogMessage(1,('PyEval@0x%x(Code="%s") Exception "%s"')%(FBID,cmd,str(e)))

   318

        self.PLCStatus = "Stopped"

   319

        self.StatusChange()

   320

        self.PythonRuntimeCall("stop")

   321

   322

    def StartPLC(self):

   323

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

   324

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

   325

            error = None

   326

            res = self._startPLC(len(self.argv),c_argv(*self.argv))

   327

            if res == 0:

   328

                self.StartSem=Semaphore(0)

   329

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

   330

                self.PythonThread.start()

   331

                self.StartSem.acquire()

   332

                self.LogMessage("PLC started")

   333

            else:

   334

                self.LogMessage(0,_("Problem starting PLC : error %d" % res))

   335

                self.PLCStatus = "Broken"

   336

                self.StatusChange()

   337

   338

    def StopPLC(self):

   339

        if self.PLCStatus == "Started":

   340

            self.LogMessage("PLC stopped")

   341

            self._stopPLC()

   342

            self.PythonThread.join()

   343

            return True

   344

        return False

   345

   346

    def _Reload(self):

   347

        self.daemon.shutdown(True)

   348

        self.daemon.sock.close()

   349

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

   350

        # never reached

   351

        return 0

   352

   353

    def ForceReload(self):

   354

        # respawn python interpreter

   355

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

   356

        return True

   357

   358

    def GetPLCstatus(self):

   359

        return self.PLCStatus, map(self.GetLogCount,xrange(LogLevelsCount))

   360

   361

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

   362

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

   363

            NewFileName = md5sum + lib_ext

   364

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

   365

   366

            self.PythonRuntimeCleanup()

   367

   368

            self._FreePLC()

   369

            self.LogMessage("NewPLC (%s)"%md5sum)

   370

            self.PLCStatus = "Empty"

   371

   372

            try:

   373

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

   374

                                       self.CurrentPLCFilename))

   375

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

   376

                    try:

   377

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

   378

                    except:

   379

                        pass

   380

            except:

   381

                pass

   382

   383

            try:

   384

                # Create new PLC file

   385

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

   386

                     'wb').write(data)

   387

   388

                # Store new PLC filename based on md5 key

   389

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

   390

   391

                # Then write the files

   392

                log = file(extra_files_log, "w")

   393

                for fname,fdata in extrafiles:

   394

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

   395

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

   396

                    log.write(fname+'\n')

   397

   398

                # Store new PLC filename

   399

                self.CurrentPLCFilename = NewFileName

   400

            except:

   401

                self.PLCStatus = "Broken"

   402

                self.StatusChange()

   403

                PLCprint(traceback.format_exc())

   404

                return False

   405

   406

            if self.LoadPLC():

   407

                self.PLCStatus = "Stopped"

   408

            else:

   409

                self.PLCStatus = "Broken"

   410

                self._FreePLC()

   411

            self.StatusChange()

   412

   413

            return self.PLCStatus == "Stopped"

   414

        return False

   415

   416

    def MatchMD5(self, MD5):

   417

        try:

   418

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

   419

            return last_md5 == MD5

   420

        except:

   421

            return False

   422

   423

   424

   425

    def SetTraceVariablesList(self, idxs):

   426

        """

   427

        Call ctype imported function to append 

   428

        these indexes to registred variables in PLC debugger

   429

        """

   430

        if idxs:

   431

            # suspend but dont disable

   432

            if self._suspendDebug(False) == 0:

   433

                # keep a copy of requested idx

   434

                self._Idxs = idxs[:]

   435

                self._ResetDebugVariables()

   436

                for idx,iectype,force in idxs:

   437

                    if force !=None:

   438

                        c_type,unpack_func, pack_func = \

   439

                            TypeTranslator.get(iectype,

   440

                                                    (None,None,None))

   441

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

   442

                    self._RegisterDebugVariable(idx, force)

   443

                self._resumeDebug()

   444

        else:

   445

            self._suspendDebug(True)

   446

            self._Idxs =  []

   447

   448

    def GetTraceVariables(self):

   449

        """

   450

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

   451

        """

   452

        if self.PLCStatus == "Started":

   453

            res=[]

   454

            tick = ctypes.c_uint32()

   455

            size = ctypes.c_uint32()

   456

            buffer = ctypes.c_void_p()

   457

            offset = 0

   458

            if self.PLClibraryLock.acquire(False):

   459

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

   460

                                      ctypes.byref(size),

   461

                                      ctypes.byref(buffer)) == 0:

   462

                    if size.value:

   463

                        for idx, iectype, forced in self._Idxs:

   464

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

   465

                            c_type,unpack_func, pack_func = \

   466

                                TypeTranslator.get(iectype,

   467

                                                        (None,None,None))

   468

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

   469

                                res.append(unpack_func(

   470

                                            ctypes.cast(cursor,

   471

                                             ctypes.POINTER(c_type)).contents))

   472

                                offset += ctypes.sizeof(c_type)

   473

                            else:

   474

                                if c_type is None:

   475

                                    PLCprint("Debug error - " + iectype +

   476

                                             " not supported !")

   477

                                #if offset >= size.value:

   478

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

   479

                                break

   480

                    self._FreeDebugData()

   481

                self.PLClibraryLock.release()

   482

            if offset and offset == size.value:

   483

                return self.PLCStatus, tick.value, res

   484

            #elif size.value:

   485