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 os, sys, getopt

    26

from threading import Thread

    27

    28

def usage():

    29

    print """

    30

Usage of Beremiz PLC execution service :\n

    31

%s {[-n servicename] [-i IP] [-p port] [-x enabletaskbar] [-a autostart]|-h|--help} working_dir

    32

           -n        - zeroconf service name (default:disabled)

    33

           -i        - IP address of interface to bind to (default:localhost)

    34

           -p        - port number default:3000

    35

           -h        - print this help text and quit

    36

           -a        - autostart PLC (0:disable 1:enable) (default:0)

    37

           -x        - enable/disable wxTaskbarIcon (0:disable 1:enable) (default:1)

    38

           -t        - enable/disable Twisted web interface (0:disable 1:enable) (default:1)

    39

    40

           working_dir - directory where are stored PLC files

    41

"""%sys.argv[0]

    42

    43

try:

    44

    opts, argv = getopt.getopt(sys.argv[1:], "i:p:n:x:t:a:h")

    45

except getopt.GetoptError, err:

    46

    # print help information and exit:

    47

    print str(err) # will print something like "option -a not recognized"

    48

    usage()

    49

    sys.exit(2)

    50

    51

# default values

    52

given_ip = None

    53

port = 3000

    54

servicename = None

    55

autostart = False

    56

enablewx = True

    57

havewx = False

    58

enabletwisted = True

    59

havetwisted = False

    60

    61

for o, a in opts:

    62

    if o == "-h":

    63

        usage()

    64

        sys.exit()

    65

    elif o == "-i":

    66

        if len(a.split(".")) == 4 or a == "localhost":

    67

            given_ip = a

    68

        else:

    69

            usage()

    70

            sys.exit()

    71

    elif o == "-p":

    72

        # port: port that the service runs on

    73

        port = int(a)

    74

    elif o == "-n":

    75

        servicename = a

    76

    elif o == "-x":

    77

        enablewx = int(a)

    78

    elif o == "-t":

    79

        enabletwisted = int(a)

    80

    elif o == "-a":

    81

        autostart = int(a)

    82

    else:

    83

        usage()

    84

        sys.exit()

    85

    86

if len(argv) > 1:

    87

    usage()

    88

    sys.exit()

    89

elif len(argv) == 1:

    90

    WorkingDir = argv[0]

    91

    os.chdir(WorkingDir)

    92

elif len(argv) == 0:

    93

    WorkingDir = os.getcwd()

    94

    argv=[WorkingDir]

    95

    96

import __builtin__

    97

if __name__ == '__main__':

    98

    __builtin__.__dict__['_'] = lambda x: x

    99

   100

if enablewx:

   101

    try:

   102

        import wx, re

   103

        from threading import Thread, currentThread

   104

        from types import *

   105

        havewx = True

   106

    except:

   107

        print "Wx unavailable !"

   108

        havewx = False

   109

   110

    if havewx:

   111

        app=wx.App(redirect=False)

   112

   113

        # Import module for internationalization

   114

        import gettext

   115

   116

        CWD = os.path.split(os.path.realpath(__file__))[0]

   117

        def Bpath(*args):

   118

            return os.path.join(CWD,*args)

   119

   120

        # Get folder containing translation files

   121

        localedir = os.path.join(CWD,"locale")

   122

        # Get the default language

   123

        langid = wx.LANGUAGE_DEFAULT

   124

        # Define translation domain (name of translation files)

   125

        domain = "Beremiz"

   126

   127

        # Define locale for wx

   128

        loc = __builtin__.__dict__.get('loc', None)

   129

        if loc is None:

   130

            loc = wx.Locale(langid)

   131

            __builtin__.__dict__['loc'] = loc

   132

        # Define location for searching translation files

   133

        loc.AddCatalogLookupPathPrefix(localedir)

   134

        # Define locale domain

   135

        loc.AddCatalog(domain)

   136

   137

        def unicode_translation(message):

   138

            return wx.GetTranslation(message).encode("utf-8")

   139

   140

        if __name__ == '__main__':

   141

            __builtin__.__dict__['_'] = wx.GetTranslation#unicode_translation

   142

   143

        defaulticon = wx.Image(Bpath("images", "brz.png"))

   144

        starticon = wx.Image(Bpath("images", "icoplay24.png"))

   145

        stopicon = wx.Image(Bpath("images", "icostop24.png"))

   146

   147

        class ParamsEntryDialog(wx.TextEntryDialog):

   148

            if wx.VERSION < (2, 6, 0):

   149

                def Bind(self, event, function, id = None):

   150

                    if id is not None:

   151

                        event(self, id, function)

   152

                    else:

   153

                        event(self, function)

   154

   155

   156

            def __init__(self, parent, message, caption = "Please enter text", defaultValue = "", 

   157

                               style = wx.OK|wx.CANCEL|wx.CENTRE, pos = wx.DefaultPosition):

   158

                wx.TextEntryDialog.__init__(self, parent, message, caption, defaultValue, style, pos)

   159

   160

                self.Tests = []

   161

                if wx.VERSION >= (2, 8, 0):

   162

                    self.Bind(wx.EVT_BUTTON, self.OnOK, id=self.GetAffirmativeId())

   163

                elif wx.VERSION >= (2, 6, 0):

   164

                    self.Bind(wx.EVT_BUTTON, self.OnOK, id=self.GetSizer().GetItem(3).GetSizer().GetAffirmativeButton().GetId())

   165

                else:

   166

                    self.Bind(wx.EVT_BUTTON, self.OnOK, id=self.GetSizer().GetItem(3).GetSizer().GetChildren()[0].GetSizer().GetChildren()[0].GetWindow().GetId())

   167

   168

            def OnOK(self, event):

   169

                value = self.GetValue()

   170

                texts = {"value" : value}

   171

                for function, message in self.Tests:

   172

                    if not function(value):

   173

                        message = wx.MessageDialog(self, message%texts, _("Error"), wx.OK|wx.ICON_ERROR)

   174

                        message.ShowModal()

   175

                        message.Destroy()

   176

                        return

   177

                self.EndModal(wx.ID_OK)

   178

                event.Skip()

   179

   180

            def GetValue(self):

   181

                return self.GetSizer().GetItem(1).GetWindow().GetValue()

   182

   183

            def SetTests(self, tests):

   184

                self.Tests = tests

   185

   186

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   187

            TBMENU_START = wx.NewId()

   188

            TBMENU_STOP = wx.NewId()

   189

            TBMENU_CHANGE_NAME = wx.NewId()

   190

            TBMENU_CHANGE_PORT = wx.NewId()

   191

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   192

            TBMENU_LIVE_SHELL = wx.NewId()

   193

            TBMENU_WXINSPECTOR = wx.NewId()

   194

            TBMENU_CHANGE_WD = wx.NewId()

   195

            TBMENU_QUIT = wx.NewId()

   196

   197

            def __init__(self, pyroserver, level):

   198

                wx.TaskBarIcon.__init__(self)

   199

                self.pyroserver = pyroserver

   200

                # Set the image

   201

                self.UpdateIcon(None)

   202

                self.level = level

   203

   204

                # bind some events

   205

                self.Bind(wx.EVT_MENU, self.OnTaskBarStartPLC, id=self.TBMENU_START)

   206

                self.Bind(wx.EVT_MENU, self.OnTaskBarStopPLC, id=self.TBMENU_STOP)

   207

                self.Bind(wx.EVT_MENU, self.OnTaskBarChangeName, id=self.TBMENU_CHANGE_NAME)

   208

                self.Bind(wx.EVT_MENU, self.OnTaskBarChangeInterface, id=self.TBMENU_CHANGE_INTERFACE)

   209

                self.Bind(wx.EVT_MENU, self.OnTaskBarLiveShell, id=self.TBMENU_LIVE_SHELL)

   210

                self.Bind(wx.EVT_MENU, self.OnTaskBarWXInspector, id=self.TBMENU_WXINSPECTOR)

   211

                self.Bind(wx.EVT_MENU, self.OnTaskBarChangePort, id=self.TBMENU_CHANGE_PORT)

   212

                self.Bind(wx.EVT_MENU, self.OnTaskBarChangeWorkingDir, id=self.TBMENU_CHANGE_WD)

   213

                self.Bind(wx.EVT_MENU, self.OnTaskBarQuit, id=self.TBMENU_QUIT)

   214

   215

            def CreatePopupMenu(self):

   216

                """

   217

                This method is called by the base class when it needs to popup

   218

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   219

                the menu how you want it and return it from this function,

   220

                the base class takes care of the rest.

   221

                """

   222

                menu = wx.Menu()

   223

                menu.Append(self.TBMENU_START, _("Start PLC"))

   224

                menu.Append(self.TBMENU_STOP, _("Stop PLC"))

   225

                if self.level==1:

   226

                    menu.AppendSeparator()

   227

                    menu.Append(self.TBMENU_CHANGE_NAME, _("Change Name"))

   228

                    menu.Append(self.TBMENU_CHANGE_INTERFACE, _("Change IP of interface to bind"))

   229

                    menu.Append(self.TBMENU_CHANGE_PORT, _("Change Port Number"))

   230

                    menu.Append(self.TBMENU_CHANGE_WD, _("Change working directory"))

   231

                    menu.AppendSeparator()

   232

                    menu.Append(self.TBMENU_LIVE_SHELL, _("Launch a live Python shell"))

   233

                    menu.Append(self.TBMENU_WXINSPECTOR, _("Launch WX GUI inspector"))

   234

                menu.AppendSeparator()

   235

                menu.Append(self.TBMENU_QUIT, _("Quit"))

   236

                return menu

   237

   238

            def MakeIcon(self, img):

   239

                """

   240

                The various platforms have different requirements for the

   241

                icon size...

   242

                """

   243

                if "wxMSW" in wx.PlatformInfo:

   244

                    img = img.Scale(16, 16)

   245

                elif "wxGTK" in wx.PlatformInfo:

   246

                    img = img.Scale(22, 22)

   247

                # wxMac can be any size upto 128x128, so leave the source img alone....

   248

                icon = wx.IconFromBitmap(img.ConvertToBitmap() )

   249

                return icon

   250

   251

            def OnTaskBarStartPLC(self, evt):

   252

                if self.pyroserver.plcobj is not None: 

   253

                    self.pyroserver.plcobj.StartPLC()

   254

   255

            def OnTaskBarStopPLC(self, evt):

   256

                if self.pyroserver.plcobj is not None:

   257

                    Thread(target=self.pyroserver.plcobj.StopPLC).start()

   258

   259

            def OnTaskBarChangeInterface(self, evt):

   260

                dlg = ParamsEntryDialog(None, _("Enter the IP of the interface to bind"), defaultValue=self.pyroserver.ip_addr)

   261

                dlg.SetTests([(re.compile('\d{1,3}(?:\.\d{1,3}){3}$').match, _("IP is not valid!")),

   262

                               ( lambda x :len([x for x in x.split(".") if 0 <= int(x) <= 255]) == 4, _("IP is not valid!"))

   263

                               ])

   264

                if dlg.ShowModal() == wx.ID_OK:

   265

                    self.pyroserver.ip_addr = dlg.GetValue()

   266

                    self.pyroserver.Stop()

   267

   268

            def OnTaskBarChangePort(self, evt):

   269

                dlg = ParamsEntryDialog(None, _("Enter a port number "), defaultValue=str(self.pyroserver.port))

   270

                dlg.SetTests([(UnicodeType.isdigit, _("Port number must be an integer!")), (lambda port : 0 <= int(port) <= 65535 , _("Port number must be 0 <= port <= 65535!"))])

   271

                if dlg.ShowModal() == wx.ID_OK:

   272

                    self.pyroserver.port = int(dlg.GetValue())

   273

                    self.pyroserver.Stop()

   274

   275

            def OnTaskBarChangeWorkingDir(self, evt):

   276

                dlg = wx.DirDialog(None, _("Choose a working directory "), self.pyroserver.workdir, wx.DD_NEW_DIR_BUTTON)

   277

                if dlg.ShowModal() == wx.ID_OK:

   278

                    self.pyroserver.workdir = dlg.GetPath()

   279

                    self.pyroserver.Stop()

   280

   281

            def OnTaskBarChangeName(self, evt):

   282

                dlg = ParamsEntryDialog(None, _("Enter a name "), defaultValue=self.pyroserver.name)

   283

                dlg.SetTests([(lambda name : len(name) is not 0 , _("Name must not be null!"))])

   284

                if dlg.ShowModal() == wx.ID_OK:

   285

                    self.pyroserver.name = dlg.GetValue()

   286

                    self.pyroserver.Restart()

   287

   288

            def _LiveShellLocals(self):

   289

                if self.pyroserver.plcobj is not None:

   290

                    return {"locals":self.pyroserver.plcobj.python_runtime_vars}

   291

                else:

   292

                    return {}

   293

   294

            def OnTaskBarLiveShell(self, evt):

   295

                from wx import py

   296

                frame = py.crust.CrustFrame(**self._LiveShellLocals())

   297

                frame.Show()

   298

   299

            def OnTaskBarWXInspector(self, evt):

   300

                # Activate the widget inspection tool

   301

                from wx.lib.inspection import InspectionTool

   302

                if not InspectionTool().initialized:

   303

                    InspectionTool().Init(**self._LiveShellLocals())

   304

   305

                wnd = wx.GetApp()

   306

                InspectionTool().Show(wnd, True)

   307

   308

            def OnTaskBarQuit(self, evt):

   309

                if wx.Platform == '__WXMSW__':

   310

                    Thread(target=self.pyroserver.Quit).start()

   311

                self.RemoveIcon()

   312

                wx.CallAfter(wx.GetApp().ExitMainLoop)

   313

   314

            def UpdateIcon(self, plcstatus):

   315

                if plcstatus is "Started" :

   316

                    currenticon = self.MakeIcon(starticon)

   317

                elif plcstatus is "Stopped":

   318

                    currenticon = self.MakeIcon(stopicon)

   319

                else:

   320

                    currenticon = self.MakeIcon(defaulticon)

   321

                self.SetIcon(currenticon, "Beremiz Service")

   322

   323

from runtime import PLCObject, PLCprint, ServicePublisher

   324

import Pyro.core as pyro

   325

   326

if not os.path.isdir(WorkingDir):

   327

    os.mkdir(WorkingDir)

   328

   329

def default_evaluator(tocall, *args, **kwargs):

   330

    try:

   331

        res=(tocall(*args,**kwargs), None)

   332

    except Exception:

   333

        res=(None, sys.exc_info())

   334

    return res

   335

   336

class Server():

   337

    def __init__(self, servicename, ip_addr, port, workdir, argv, autostart=False, statuschange=None, evaluator=default_evaluator, website=None):

   338

        self.continueloop = True

   339

        self.daemon = None

   340

        self.servicename = servicename

   341

        self.ip_addr = ip_addr

   342

        self.port = port

   343

        self.workdir = workdir

   344

        self.argv = argv

   345

        self.plcobj = None

   346

        self.servicepublisher = None

   347

        self.autostart = autostart

   348

        self.statuschange = statuschange

   349

        self.evaluator = evaluator

   350

        self.website = website

   351

   352

    def Loop(self):

   353

        while self.continueloop:

   354

            self.Start()

   355

   356

    def Restart(self):

   357

        self.Stop()

   358

   359

    def Quit(self):

   360

        self.continueloop = False

   361

        if self.plcobj is not None:

   362

            self.plcobj.UnLoadPLC()

   363

        self.Stop()

   364

   365

    def Start(self):

   366

        pyro.initServer()

   367

        self.daemon=pyro.Daemon(host=self.ip_addr, port=self.port)

   368

        self.plcobj = PLCObject(self.workdir, self.daemon, self.argv, self.statuschange, self.evaluator, self.website)

   369

        uri = self.daemon.connect(self.plcobj,"PLCObject")

   370

   371

        print "Pyro port :",self.port

   372

        print "Pyro object's uri :",uri

   373

        print "Current working directory :",self.workdir

   374

   375

        # Configure and publish service

   376

        # Not publish service if localhost in address params

   377

        if (self.servicename is not None and 

   378

            self.ip_addr is not None and 

   379

            self.ip_addr != "localhost" and 

   380

            self.ip_addr != "127.0.0.1"):

   381

            print "Publishing service on local network"

   382

            self.servicepublisher = ServicePublisher.ServicePublisher()

   383

            self.servicepublisher.RegisterService(self.servicename, self.ip_addr, self.port)

   384

   385

        if self.autostart and self.plcobj.GetPLCstatus()[0] != "Empty":

   386

            self.plcobj.StartPLC()

   387

   388

        sys.stdout.flush()

   389

   390

        self.daemon.requestLoop()

   391

   392

    def Stop(self):

   393

        if self.plcobj is not None:

   394

            self.plcobj.StopPLC()

   395

        if self.servicepublisher is not None:

   396

            self.servicepublisher.UnRegisterService()

   397

            self.servicepublisher = None

   398

        self.daemon.shutdown(True)

   399

   400

if enabletwisted:

   401

    import warnings

   402

    with warnings.catch_warnings():

   403

        warnings.simplefilter("ignore")

   404

        try:

   405

            from threading import Thread, currentThread

   406

            if havewx:

   407

                from twisted.internet import wxreactor

   408

                wxreactor.install()

   409

            from twisted.internet import reactor, task

   410

            from twisted.python import log, util

   411

            from nevow import rend, appserver, inevow, tags, loaders, athena

   412

            from nevow.page import renderer

   413

   414

            havetwisted = True

   415

        except:

   416

            print "Twisted unavailable !"

   417

            havetwisted = False

   418

   419

if havetwisted:

   420

   421

    xhtml_header = '''<?xml version="1.0" encoding="utf-8"?>

   422

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"

   423

"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

   424

'''

   425

   426

    class PLCHMI(athena.LiveElement):

   427

   428

        initialised = False

   429

   430

        def HMIinitialised(self, result):

   431

            self.initialised = True

   432

   433

        def HMIinitialisation(self):

   434

            self.HMIinitialised(None)

   435

   436

    class DefaultPLCStartedHMI(PLCHMI):

   437

        docFactory = loaders.stan(tags.div(render=tags.directive('liveElement'))[                                    

   438

                                             tags.h1["PLC IS NOW STARTED"],

   439

                                             ])

   440

   441

    class PLCStoppedHMI(PLCHMI):

   442

        docFactory = loaders.stan(tags.div(render=tags.directive('liveElement'))[

   443

                                             tags.h1["PLC IS STOPPED"],

   444

                                             ])

   445

   446

    class MainPage(athena.LiveElement):

   447

        jsClass = u"WebInterface.PLC"

   448

        docFactory = loaders.stan(tags.div(render=tags.directive('liveElement'))[

   449

                                                        tags.div(id='content')[                         

   450

                                                        tags.div(render = tags.directive('PLCElement')),

   451

                                                        ]])

   452

   453

        def __init__(self, *a, **kw):

   454

            athena.LiveElement.__init__(self, *a, **kw)

   455

            self.pcl_state = False

   456

            self.HMI = None

   457

            self.resetPLCStartedHMI()

   458

   459

        def setPLCState(self, state):

   460

            self.pcl_state = state

   461

            if self.HMI is not None:

   462

                self.callRemote('updateHMI')

   463

   464

        def setPLCStartedHMI(self, hmi):

   465

            self.PLCStartedHMIClass = hmi

   466

   467

        def resetPLCStartedHMI(self):

   468

            self.PLCStartedHMIClass = DefaultPLCStartedHMI

   469

   470

        def getHMI(self):

   471

            return self.HMI

   472

   473

        def HMIexec(self, function, *args, **kwargs):

   474

            if self.HMI is not None:

   475

                getattr(self.HMI, function, lambda:None)(*args, **kwargs)

   476

        athena.expose(HMIexec)

   477

   478

        def resetHMI(self):

   479

            self.HMI = None

   480

   481

        def PLCElement(self, ctx, data):

   482

            return self.getPLCElement()

   483

        renderer(PLCElement)

   484

   485

        def getPLCElement(self):

   486

            self.detachFragmentChildren()

   487

            if self.pcl_state:

   488

                f = self.PLCStartedHMIClass()

   489

            else:

   490

                f = PLCStoppedHMI()

   491

            f.setFragmentParent(self)

   492

            self.HMI = f