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

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

    87

    88

if len(argv) > 1:

    89

    usage()

    90

    sys.exit()

    91

elif len(argv) == 1:

    92

    WorkingDir = argv[0]

    93

    os.chdir(WorkingDir)

    94

elif len(argv) == 0:

    95

    WorkingDir = os.getcwd()

    96

    argv=[WorkingDir]

    97

    98

import __builtin__

    99

if __name__ == '__main__':

   100

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

   101

   102

if enablewx:

   103

    try:

   104

        import wx, re

   105

        from threading import Thread, currentThread

   106

        from types import *

   107

        havewx = True

   108

    except:

   109

        print "Wx unavailable !"

   110

        havewx = False

   111

   112

    if havewx:

   113

        app=wx.App(redirect=False)

   114

   115

        # Import module for internationalization

   116

        import gettext

   117

   118

        def Bpath(*args):

   119

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

   120

   121

        # Get folder containing translation files

   122

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

   123

        # Get the default language

   124

        langid = wx.LANGUAGE_DEFAULT

   125

        # Define translation domain (name of translation files)

   126

        domain = "Beremiz"

   127

   128

        # Define locale for wx

   129

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

   130

        if loc is None:

   131

            loc = wx.Locale(langid)

   132

            __builtin__.__dict__['loc'] = loc

   133

        # Define location for searching translation files

   134

        loc.AddCatalogLookupPathPrefix(localedir)

   135

        # Define locale domain

   136

        loc.AddCatalog(domain)

   137

   138

        def unicode_translation(message):

   139

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

   140

   141

        if __name__ == '__main__':

   142

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

   143

   144

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

   145

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

   146

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

   147

   148

        class ParamsEntryDialog(wx.TextEntryDialog):

   149

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

   150

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

   151

                    if id is not None:

   152

                        event(self, id, function)

   153

                    else:

   154

                        event(self, function)

   155

   156

   157

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

   158

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

   159

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

   160

   161

                self.Tests = []

   162

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

   163

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

   164

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

   165

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

   166

                else:

   167

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

   168

   169

            def OnOK(self, event):

   170

                value = self.GetValue()

   171

                texts = {"value" : value}

   172

                for function, message in self.Tests:

   173

                    if not function(value):

   174

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

   175

                        message.ShowModal()

   176

                        message.Destroy()

   177

                        return

   178

                self.EndModal(wx.ID_OK)

   179

                event.Skip()

   180

   181

            def GetValue(self):

   182

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

   183

   184

            def SetTests(self, tests):

   185

                self.Tests = tests

   186

   187

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   188

            TBMENU_START = wx.NewId()

   189

            TBMENU_STOP = wx.NewId()

   190

            TBMENU_CHANGE_NAME = wx.NewId()

   191

            TBMENU_CHANGE_PORT = wx.NewId()

   192

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   193

            TBMENU_LIVE_SHELL = wx.NewId()

   194

            TBMENU_WXINSPECTOR = wx.NewId()

   195

            TBMENU_CHANGE_WD = wx.NewId()

   196

            TBMENU_QUIT = wx.NewId()

   197

   198

            def __init__(self, pyroserver, level):

   199

                wx.TaskBarIcon.__init__(self)

   200

                self.pyroserver = pyroserver

   201

                # Set the image

   202

                self.UpdateIcon(None)

   203

                self.level = level

   204

   205

                # bind some events

   206

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

   207

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

   208

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

   209

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

   210

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

   211

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

   212

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

   213

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

   214

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

   215

   216

            def CreatePopupMenu(self):

   217

                """

   218

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

   219

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   220

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

   221

                the base class takes care of the rest.

   222

                """

   223

                menu = wx.Menu()

   224

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

   225

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

   226

                if self.level==1:

   227

                    menu.AppendSeparator()

   228

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

   229

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

   230

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

   231

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

   232

                    menu.AppendSeparator()

   233

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

   234

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

   235

                menu.AppendSeparator()

   236

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

   237

                return menu

   238

   239

            def MakeIcon(self, img):

   240

                """

   241

                The various platforms have different requirements for the

   242

                icon size...

   243

                """

   244

                if "wxMSW" in wx.PlatformInfo:

   245

                    img = img.Scale(16, 16)

   246

                elif "wxGTK" in wx.PlatformInfo:

   247

                    img = img.Scale(22, 22)

   248

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

   249

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

   250

                return icon

   251

   252

            def OnTaskBarStartPLC(self, evt):

   253

                if self.pyroserver.plcobj is not None:

   254

                    self.pyroserver.plcobj.StartPLC()

   255

   256

            def OnTaskBarStopPLC(self, evt):

   257

                if self.pyroserver.plcobj is not None:

   258

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

   259

   260

            def OnTaskBarChangeInterface(self, evt):

   261

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

   262

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

   263

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

   264

                               ])

   265

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

   266

                    self.pyroserver.ip_addr = dlg.GetValue()

   267

                    self.pyroserver.Stop()

   268

   269

            def OnTaskBarChangePort(self, evt):

   270

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

   271

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

   272

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

   273

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

   274

                    self.pyroserver.Stop()

   275

   276

            def OnTaskBarChangeWorkingDir(self, evt):

   277

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

   278

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

   279

                    self.pyroserver.workdir = dlg.GetPath()

   280

                    self.pyroserver.Stop()

   281

   282

            def OnTaskBarChangeName(self, evt):

   283

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

   284

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

   285

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

   286

                    self.pyroserver.name = dlg.GetValue()

   287

                    self.pyroserver.Restart()

   288

   289

            def _LiveShellLocals(self):

   290

                if self.pyroserver.plcobj is not None:

   291

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

   292

                else:

   293

                    return {}

   294

   295

            def OnTaskBarLiveShell(self, evt):

   296

                from wx import py

   297

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

   298

                frame.Show()

   299

   300

            def OnTaskBarWXInspector(self, evt):

   301

                # Activate the widget inspection tool

   302

                from wx.lib.inspection import InspectionTool

   303

                if not InspectionTool().initialized:

   304

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

   305

   306

                wnd = wx.GetApp()

   307

                InspectionTool().Show(wnd, True)

   308

   309

            def OnTaskBarQuit(self, evt):

   310

                if wx.Platform == '__WXMSW__':

   311

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

   312

                self.RemoveIcon()

   313

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

   314

   315

            def UpdateIcon(self, plcstatus):

   316

                if plcstatus is "Started" :

   317

                    currenticon = self.MakeIcon(starticon)

   318

                elif plcstatus is "Stopped":

   319

                    currenticon = self.MakeIcon(stopicon)

   320

                else:

   321

                    currenticon = self.MakeIcon(defaulticon)

   322

                self.SetIcon(currenticon, "Beremiz Service")

   323

   324

from runtime import PLCObject, PLCprint, ServicePublisher

   325

import Pyro.core as pyro

   326

   327

if not os.path.isdir(WorkingDir):

   328

    os.mkdir(WorkingDir)

   329

   330

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

   331

    try:

   332

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

   333

    except Exception:

   334

        res=(None, sys.exc_info())

   335

    return res

   336

   337

class Server():

   338

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

   339

        self.continueloop = True

   340

        self.daemon = None

   341

        self.servicename = servicename

   342

        self.ip_addr = ip_addr

   343

        self.port = port

   344

        self.workdir = workdir

   345

        self.argv = argv

   346

        self.plcobj = None

   347

        self.servicepublisher = None

   348

        self.autostart = autostart

   349

        self.statuschange = statuschange

   350

        self.evaluator = evaluator

   351

        self.website = website

   352

   353

    def Loop(self):

   354

        while self.continueloop:

   355

            self.Start()

   356

   357

    def Restart(self):

   358

        self.Stop()

   359

   360

    def Quit(self):

   361

        self.continueloop = False

   362

        if self.plcobj is not None:

   363

            self.plcobj.UnLoadPLC()

   364

        self.Stop()

   365

   366

    def Start(self):

   367

        pyro.initServer()

   368

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

   369

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

   370

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

   371

   372

        print "Pyro port :",self.port

   373

        print "Pyro object's uri :",uri

   374

        print "Current working directory :",self.workdir

   375

   376

        # Configure and publish service

   377

        # Not publish service if localhost in address params

   378

        if (self.servicename is not None and

   379

            self.ip_addr is not None and

   380

            self.ip_addr != "localhost" and

   381

            self.ip_addr != "127.0.0.1"):

   382

            print "Publishing service on local network"

   383

            self.servicepublisher = ServicePublisher.ServicePublisher()

   384

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

   385

   386

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

   387

            self.plcobj.StartPLC()

   388

   389

        sys.stdout.flush()

   390

   391

        self.daemon.requestLoop()

   392

   393

    def Stop(self):

   394

        if self.plcobj is not None:

   395

            self.plcobj.StopPLC()

   396

        if self.servicepublisher is not None:

   397

            self.servicepublisher.UnRegisterService()

   398

            self.servicepublisher = None

   399

        self.daemon.shutdown(True)

   400

   401

if enabletwisted:

   402

    import warnings

   403

    with warnings.catch_warnings():

   404

        warnings.simplefilter("ignore")

   405

        try:

   406

            from threading import Thread, currentThread

   407

            if havewx:

   408

                from twisted.internet import wxreactor

   409

                wxreactor.install()

   410

            from twisted.internet import reactor, task

   411

            from twisted.python import log, util

   412

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

   413

            from nevow.page import renderer

   414

   415

            havetwisted = True

   416

        except:

   417

            print "Twisted unavailable !"

   418

            havetwisted = False

   419

   420

if havetwisted:

   421

   422

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

   423

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

   424

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

   425

'''

   426

   427

    class PLCHMI(athena.LiveElement):

   428

   429

        initialised = False

   430

   431

        def HMIinitialised(self, result):

   432

            self.initialised = True

   433

   434

        def HMIinitialisation(self):

   435

            self.HMIinitialised(None)

   436

   437

    class DefaultPLCStartedHMI(PLCHMI):

   438

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

   439

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

   440

                                             ])

   441

   442

    class PLCStoppedHMI(PLCHMI):

   443

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

   444

                                             tags.h1["PLC IS STOPPED"],

   445

                                             ])

   446

   447

    class MainPage(athena.LiveElement):

   448

        jsClass = u"WebInterface.PLC"

   449

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

   450

                                                        tags.div(id='content')[

   451

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

   452

                                                        ]])

   453

   454

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

   455

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

   456

            self.pcl_state = False

   457

            self.HMI = None

   458

            self.resetPLCStartedHMI()

   459

   460

        def setPLCState(self, state):

   461

            self.pcl_state = state

   462

            if self.HMI is not None:

   463

                self.callRemote('updateHMI')

   464

   465

        def setPLCStartedHMI(self, hmi):

   466

            self.PLCStartedHMIClass = hmi

   467

   468

        def resetPLCStartedHMI(self):

   469

            self.PLCStartedHMIClass = DefaultPLCStartedHMI

   470

   471

        def getHMI(self):

   472

            return self.HMI

   473

   474

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

   475

            if self.HMI is not None:

   476

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

   477

        athena.expose(HMIexec)

   478

   479

        def resetHMI(self):

   480

            self.HMI = None

   481

   482

        def PLCElement(self, ctx, data):

   483

            return self.getPLCElement()

   484

        renderer(PLCElement)

   485

   486

        def getPLCElement(self):