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)

    40

    41

           working_dir - directory where are stored PLC files

    42

"""%sys.argv[0]

    43

    44

try:

    46

except getopt.GetoptError, err:

    47

    # print help information and exit:

    48

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

    49

    usage()

    50

    sys.exit(2)

    51

    52

# default values

    53

given_ip = None

    54

port = 3000

    55

servicename = None

    56

autostart = False

    57

enablewx = True

    58

havewx = False

    59

enabletwisted = True

    60

havetwisted = False

    61

    64

for o, a in opts:

    65

    if o == "-h":

    66

        usage()

    67

        sys.exit()

    68

    elif o == "-i":

    69

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

    70

            given_ip = a

    71

        else:

    72

            usage()

    73

            sys.exit()

    74

    elif o == "-p":

    75

        # port: port that the service runs on

    76

        port = int(a)

    77

    elif o == "-n":

    78

        servicename = a

    79

    elif o == "-x":

    80

        enablewx = int(a)

    81

    elif o == "-t":

    82

        enabletwisted = int(a)

    83

    elif o == "-a":

    84

        autostart = int(a)

    87

    else:

    88

        usage()

    89

        sys.exit()

    90

    91

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

    92

    93

if len(argv) > 1:

    94

    usage()

    95

    sys.exit()

    96

elif len(argv) == 1:

    97

    WorkingDir = argv[0]

    98

    os.chdir(WorkingDir)

    99

elif len(argv) == 0:

   100

    WorkingDir = os.getcwd()

   101

    argv=[WorkingDir]

   102

   103

import __builtin__

   104

if __name__ == '__main__':

   105

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

   106

   107

if enablewx:

   108

    try:

   109

        import wx, re

   110

        from threading import Thread, currentThread

   111

        from types import *

   112

        havewx = True

   113

    except:

   114

        print "Wx unavailable !"

   115

        havewx = False

   116

   117

    if havewx:

   118

        app=wx.App(redirect=False)

   119

   120

        # Import module for internationalization

   121

        import gettext

   122

   123

        def Bpath(*args):

   124

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

   125

   126

        # Get folder containing translation files

   127

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

   128

        # Get the default language

   129

        langid = wx.LANGUAGE_DEFAULT

   130

        # Define translation domain (name of translation files)

   131

        domain = "Beremiz"

   132

   133

        # Define locale for wx

   134

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

   135

        if loc is None:

   136

            loc = wx.Locale(langid)

   137

            __builtin__.__dict__['loc'] = loc

   138

        # Define location for searching translation files

   139

        loc.AddCatalogLookupPathPrefix(localedir)

   140

        # Define locale domain

   141

        loc.AddCatalog(domain)

   142

   143

        def unicode_translation(message):

   144

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

   145

   146

        if __name__ == '__main__':

   147

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

   148

   149

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

   150

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

   151

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

   152

   153

        class ParamsEntryDialog(wx.TextEntryDialog):

   154

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

   155

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

   156

                    if id is not None:

   157

                        event(self, id, function)

   158

                    else:

   159

                        event(self, function)

   160

   161

   162

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

   163

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

   164

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

   165

   166

                self.Tests = []

   167

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

   168

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

   169

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

   170

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

   171

                else:

   172

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

   173

   174

            def OnOK(self, event):

   175

                value = self.GetValue()

   176

                texts = {"value" : value}

   177

                for function, message in self.Tests:

   178

                    if not function(value):

   179

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

   180

                        message.ShowModal()

   181

                        message.Destroy()

   182

                        return

   183

                self.EndModal(wx.ID_OK)

   184

                event.Skip()

   185

   186

            def GetValue(self):

   187

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

   188

   189

            def SetTests(self, tests):

   190

                self.Tests = tests

   191

   192

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   193

            TBMENU_START = wx.NewId()

   194

            TBMENU_STOP = wx.NewId()

   195

            TBMENU_CHANGE_NAME = wx.NewId()

   196

            TBMENU_CHANGE_PORT = wx.NewId()

   197

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   198

            TBMENU_LIVE_SHELL = wx.NewId()

   199

            TBMENU_WXINSPECTOR = wx.NewId()

   200

            TBMENU_CHANGE_WD = wx.NewId()

   201

            TBMENU_QUIT = wx.NewId()

   202

   203

            def __init__(self, pyroserver, level):

   204

                wx.TaskBarIcon.__init__(self)

   205

                self.pyroserver = pyroserver

   206

                # Set the image

   207

                self.UpdateIcon(None)

   208

                self.level = level

   209

   210

                # bind some events

   211

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

   212

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

   213

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

   214

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

   215

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

   216

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

   217

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

   218

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

   219

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

   220

   221

            def CreatePopupMenu(self):

   222

                """

   223

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

   224

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   225

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

   226

                the base class takes care of the rest.

   227

                """

   228

                menu = wx.Menu()

   229

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

   230

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

   231

                if self.level==1:

   232

                    menu.AppendSeparator()

   233

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

   234

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

   235

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

   236

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

   237

                    menu.AppendSeparator()

   238

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

   239

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

   240

                menu.AppendSeparator()

   241

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

   242

                return menu

   243

   244

            def MakeIcon(self, img):

   245

                """

   246

                The various platforms have different requirements for the

   247

                icon size...

   248

                """

   249

                if "wxMSW" in wx.PlatformInfo:

   250

                    img = img.Scale(16, 16)

   251

                elif "wxGTK" in wx.PlatformInfo:

   252

                    img = img.Scale(22, 22)

   253

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

   254

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

   255

                return icon

   256

   257

            def OnTaskBarStartPLC(self, evt):

   258

                if self.pyroserver.plcobj is not None:

   259

                    self.pyroserver.plcobj.StartPLC()

   260

   261

            def OnTaskBarStopPLC(self, evt):

   262

                if self.pyroserver.plcobj is not None:

   263

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

   264

   265

            def OnTaskBarChangeInterface(self, evt):

   266

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

   267

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

   268

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

   269

                               ])

   270

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

   271

                    self.pyroserver.ip_addr = dlg.GetValue()

   272

                    self.pyroserver.Stop()

   273

   274

            def OnTaskBarChangePort(self, evt):

   275

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

   276

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

   277

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

   278

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

   279

                    self.pyroserver.Stop()

   280

   281

            def OnTaskBarChangeWorkingDir(self, evt):

   282

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

   283

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

   284

                    self.pyroserver.workdir = dlg.GetPath()

   285

                    self.pyroserver.Stop()

   286

   287

            def OnTaskBarChangeName(self, evt):

   288

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

   289

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

   290

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

   291

                    self.pyroserver.name = dlg.GetValue()

   292

                    self.pyroserver.Restart()

   293

   294

            def _LiveShellLocals(self):

   295

                if self.pyroserver.plcobj is not None:

   296

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

   297

                else:

   298

                    return {}

   299

   300

            def OnTaskBarLiveShell(self, evt):

   301

                from wx import py

   302

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

   303

                frame.Show()

   304

   305

            def OnTaskBarWXInspector(self, evt):

   306

                # Activate the widget inspection tool

   307

                from wx.lib.inspection import InspectionTool

   308

                if not InspectionTool().initialized:

   309

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

   310

   311

                wnd = wx.GetApp()

   312

                InspectionTool().Show(wnd, True)

   313

   314

            def OnTaskBarQuit(self, evt):

   315

                if wx.Platform == '__WXMSW__':

   316

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

   317

                self.RemoveIcon()

   318

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

   319

   320

            def UpdateIcon(self, plcstatus):

   321

                if plcstatus is "Started" :

   322

                    currenticon = self.MakeIcon(starticon)

   323

                elif plcstatus is "Stopped":

   324

                    currenticon = self.MakeIcon(stopicon)

   325

                else:

   326

                    currenticon = self.MakeIcon(defaulticon)

   327

                self.SetIcon(currenticon, "Beremiz Service")

   328

   329

from runtime import PLCObject, PLCprint, ServicePublisher

   330

import Pyro.core as pyro

   331

   332

if not os.path.isdir(WorkingDir):

   333

    os.mkdir(WorkingDir)

   334

   335

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

   336

    try:

   337

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

   338

    except Exception:

   339

        res=(None, sys.exc_info())

   340

    return res

   341

   342

class Server():

   343

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

   344

        self.continueloop = True

   345

        self.daemon = None

   346

        self.servicename = servicename

   347

        self.ip_addr = ip_addr

   348

        self.port = port

   349

        self.workdir = workdir

   350

        self.argv = argv

   351

        self.plcobj = None

   352

        self.servicepublisher = None

   353

        self.autostart = autostart

   354

        self.statuschange = statuschange

   355

        self.evaluator = evaluator

   356

        self.website = website

   357

   358

    def Loop(self):

   359

        while self.continueloop:

   360

            self.Start()

   361

   362

    def Restart(self):

   363

        self.Stop()

   364

   365

    def Quit(self):

   366

        self.continueloop = False

   367

        if self.plcobj is not None:

   368

            self.plcobj.UnLoadPLC()

   369

        self.Stop()

   370

   371

    def Start(self):

   372

        pyro.initServer()

   373

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

   374

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

   375

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

   376

   377

        print "Pyro port :",self.port

   378

        print "Pyro object's uri :",uri

   379

        print "Current working directory :",self.workdir

   380

   381

        # Configure and publish service

   382

        # Not publish service if localhost in address params

   383

        if (self.servicename is not None and

   384

            self.ip_addr is not None and

   385

            self.ip_addr != "localhost" and

   386

            self.ip_addr != "127.0.0.1"):

   387

            print "Publishing service on local network"

   388

            self.servicepublisher = ServicePublisher.ServicePublisher()

   389

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

   390

   391

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

   392

            self.plcobj.StartPLC()

   393

   394

        sys.stdout.flush()

   395

   396

        self.daemon.requestLoop()

   397

   398

    def Stop(self):

   399

        if self.plcobj is not None:

   400

            self.plcobj.StopPLC()

   401

        if self.servicepublisher is not None:

   402

            self.servicepublisher.UnRegisterService()

   403

            self.servicepublisher = None

   404

        self.daemon.shutdown(True)

   405

   406

if enabletwisted:

   407

    import warnings

   408

    with warnings.catch_warnings():

   409

        warnings.simplefilter("ignore")

   410

        try:

   411

            from threading import Thread, currentThread

   412

            if havewx:

   413

                from twisted.internet import wxreactor

   414

                wxreactor.install()

   415

            from twisted.internet import reactor, task

   416

            from twisted.python import log, util

   417

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

   418

            from nevow.page import renderer

   419

   420

            havetwisted = True

   421

        except:

   422

            print "Twisted unavailable !"

   423

            havetwisted = False

   424

   425

if havetwisted:

   426

   427

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

   428

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

   429

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

   430

'''

   431

   432

    class PLCHMI(athena.LiveElement):

   433

   434

        initialised = False

   435

   436

        def HMIinitialised(self, result):

   437

            self.initialised = True

   438

   439

        def HMIinitialisation(self):

   440

            self.HMIinitialised(None)

   441

   442

    class DefaultPLCStartedHMI(PLCHMI):

   443

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

   444

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

   445

                                             ])

   446

   447

    class PLCStoppedHMI(PLCHMI):

   448

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

   449

                                             tags.h1["PLC IS STOPPED"],

   450

                                             ])

   451

   452

    class MainPage(athena.LiveElement):

   453

        jsClass = u"WebInterface.PLC"

   454

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

   455

                                                        tags.div(id='content')[

   456

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

   457

                                                        ]])

   458

   459

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

   460

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

   461

            self.pcl_state = False

   462

            self.HMI = None

   463

            self.resetPLCStartedHMI()

   464

   465

        def setPLCState(self, state):

   466

            self.pcl_state = state

   467

            if self.HMI is not None:

   468

                self.callRemote('updateHMI')

   469

   470

        def setPLCStartedHMI(self, hmi):

   471

            self.PLCStartedHMIClass = hmi

   472

   473

        def resetPLCStartedHMI(self):

   474

            self.PLCStartedHMIClass = DefaultPLCStartedHMI

   475

   476

        def getHMI(self):

   477

            return self.HMI

   478

   479

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

   480

            if self.HMI is not None:

   481

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

   482

        athena.expose(HMIexec)

   483

   484

        def resetHMI(self):

   485

            self.HMI = None

   486