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

                self.RemoveIcon()

   310

                wx.CallAfter(wx.GetApp().Exit)

   311

   312

            def UpdateIcon(self, plcstatus):

   313

                if plcstatus is "Started" :

   314

                    currenticon = self.MakeIcon(starticon)

   315

                elif plcstatus is "Stopped":

   316

                    currenticon = self.MakeIcon(stopicon)

   317

                else:

   318

                    currenticon = self.MakeIcon(defaulticon)

   319

                self.SetIcon(currenticon, "Beremiz Service")

   320

   321

from runtime import PLCObject, PLCprint, ServicePublisher

   322

import Pyro.core as pyro

   323

   324

if not os.path.isdir(WorkingDir):

   325

    os.mkdir(WorkingDir)

   326

   327

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

   328

    try:

   329

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

   330

    except Exception:

   331

        res=(None, sys.exc_info())

   332

    return res

   333

   334

class Server():

   335

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

   336

        self.continueloop = True

   337

        self.daemon = None

   338

        self.servicename = servicename

   339

        self.ip_addr = ip_addr

   340

        self.port = port

   341

        self.workdir = workdir

   342

        self.argv = argv

   343

        self.plcobj = None

   344

        self.servicepublisher = None

   345

        self.autostart = autostart

   346

        self.statuschange = statuschange

   347

        self.evaluator = evaluator

   348

        self.website = website

   349

   350

    def Loop(self):

   351

        while self.continueloop:

   352

            self.Start()

   353

   354

    def Restart(self):

   355

        self.Stop()

   356

   357

    def Quit(self):

   358

        self.continueloop = False

   359

        if self.plcobj is not None:

   360

            self.plcobj.UnLoadPLC()

   361

        self.Stop()

   362

   363

    def Start(self):

   364

        pyro.initServer()

   365

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

   366

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

   367

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

   368

   369

        print "Pyro port :",self.port

   370

        print "Pyro object's uri :",uri

   371

        print "Current working directory :",self.workdir

   372

   373

        # Configure and publish service

   374

        # Not publish service if localhost in address params

   375

        if (self.servicename is not None and 

   376

            self.ip_addr is not None and 

   377

            self.ip_addr != "localhost" and 

   378

            self.ip_addr != "127.0.0.1"):

   379

            print "Publishing service on local network"

   380

            self.servicepublisher = ServicePublisher.ServicePublisher()

   381

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

   382

   383

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

   384

            self.plcobj.LoadPLC()

   385

            self.plcobj.StartPLC()

   386

   387

        sys.stdout.flush()

   388

   389

        self.daemon.requestLoop()

   390

   391

    def Stop(self):

   392

        if self.plcobj is not None:

   393

            self.plcobj.StopPLC()

   394

        if self.servicepublisher is not None:

   395

            self.servicepublisher.UnRegisterService()

   396

            self.servicepublisher = None

   397

        self.daemon.shutdown(True)

   398

   399

if enabletwisted:

   400

    import warnings

   401

    with warnings.catch_warnings():

   402

        warnings.simplefilter("ignore")

   403

        try:

   404

            from threading import Thread, currentThread

   405

            if havewx:

   406

                from twisted.internet import wxreactor

   407

                wxreactor.install()

   408

            from twisted.internet import reactor, task

   409

            from twisted.python import log, util

   410

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

   411

            from nevow.page import renderer

   412

   413

            havetwisted = True

   414

        except:

   415

            print "Twisted unavailable !"

   416

            havetwisted = False

   417

   418

if havetwisted:

   419

   420

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

   421

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

   422

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

   423

'''

   424

   425

    class PLCHMI(athena.LiveElement):

   426

   427

        initialised = False

   428

   429

        def HMIinitialised(self, result):

   430

            self.initialised = True

   431

   432

        def HMIinitialisation(self):

   433

            self.HMIinitialised(None)

   434

   435

    class DefaultPLCStartedHMI(PLCHMI):

   436

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

   437

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

   438

                                             ])

   439

   440

    class PLCStoppedHMI(PLCHMI):

   441

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

   442

                                             tags.h1["PLC IS STOPPED"],

   443

                                             ])

   444

   445

    class MainPage(athena.LiveElement):

   446

        jsClass = u"WebInterface.PLC"

   447

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

   448

                                                        tags.div(id='content')[                         

   449

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

   450

                                                        ]])

   451

   452

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

   453

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

   454

            self.pcl_state = False

   455

            self.HMI = None

   456

            self.resetPLCStartedHMI()

   457

   458

        def setPLCState(self, state):

   459

            self.pcl_state = state

   460

            if self.HMI is not None:

   461

                self.callRemote('updateHMI')

   462

   463

        def setPLCStartedHMI(self, hmi):

   464

            self.PLCStartedHMIClass = hmi

   465

   466

        def resetPLCStartedHMI(self):

   467

            self.PLCStartedHMIClass = DefaultPLCStartedHMI

   468

   469

        def getHMI(self):

   470

            return self.HMI

   471

   472

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

   473

            if self.HMI is not None:

   474

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

   475

        athena.expose(HMIexec)

   476

   477

        def resetHMI(self):

   478

            self.HMI = None

   479

   480

        def PLCElement(self, ctx, data):

   481

            return self.getPLCElement()

   482

        renderer(PLCElement)

   483

   484

        def getPLCElement(self):

   485

            self.detachFragmentChildren()

   486

            if self.pcl_state:

   487

                f = self.PLCStartedHMIClass()

   488

            else:

   489

                f = PLCStoppedHMI()

   490

            f.setFragmentParent(self)

   491

            self.HMI = f

   492

            return f