1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     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

from xml.dom import minidom

    26

from types import StringType, UnicodeType, TupleType

    27

from lxml import etree

    28

from copy import deepcopy

    29

import os,sys,re

    30

import datetime

    31

from time import localtime

    32

    33

from plcopen import *

    34

from graphics.GraphicCommons import *

    35

from PLCGenerator import *

    36

    37

duration_model = re.compile("(?:([0-9]{1,2})h)?(?:([0-9]{1,2})m(?!s))?(?:([0-9]{1,2})s)?(?:([0-9]{1,3}(?:\.[0-9]*)?)ms)?")

    38

    39

ITEMS_EDITABLE = [ITEM_PROJECT,

    40

                  ITEM_POU,

    41

                  ITEM_VARIABLE,

    42

                  ITEM_TRANSITION,

    43

                  ITEM_ACTION,

    44

                  ITEM_CONFIGURATION,

    45

                  ITEM_RESOURCE,

    46

                  ITEM_DATATYPE

    47

                 ] = range(8)

    48

    49

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    50

                    ITEM_FUNCTION,

    51

                    ITEM_FUNCTIONBLOCK,

    52

                    ITEM_PROGRAM,

    53

                    ITEM_TRANSITIONS,

    54

                    ITEM_ACTIONS,

    55

                    ITEM_CONFIGURATIONS,

    56

                    ITEM_RESOURCES,

    57

                    ITEM_PROPERTIES

    58

                   ] = range(8, 17)

    59

    60

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    61

                  ITEM_VAR_GLOBAL,

    62

                  ITEM_VAR_EXTERNAL,

    63

                  ITEM_VAR_TEMP,

    64

                  ITEM_VAR_INPUT,

    65

                  ITEM_VAR_OUTPUT,

    66

                  ITEM_VAR_INOUT

    67

                 ] = range(17, 24)

    68

    69

VAR_CLASS_INFOS = {

    70

    "Local":    ("localVars",    ITEM_VAR_LOCAL),

    71

    "Global":   ("globalVars",   ITEM_VAR_GLOBAL),

    72

    "External": ("externalVars", ITEM_VAR_EXTERNAL),

    73

    "Temp":     ("tempVars",     ITEM_VAR_TEMP),

    74

    "Input":    ("inputVars",    ITEM_VAR_INPUT),

    75

    "Output":   ("outputVars",   ITEM_VAR_OUTPUT),

    76

    "InOut":    ("inOutVars",    ITEM_VAR_INOUT)}

    77

    78

POU_TYPES = {"program": ITEM_PROGRAM,

    79

             "functionBlock": ITEM_FUNCTIONBLOCK,

    80

             "function": ITEM_FUNCTION,

    81

            }

    82

    83

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    84

                   LOCATION_MODULE,

    85

                   LOCATION_GROUP,

    86

                   LOCATION_VAR_INPUT,

    87

                   LOCATION_VAR_OUTPUT,

    88

                   LOCATION_VAR_MEMORY] = range(6)

    89

    90

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

    91

    92

def GetUneditableNames():

    93

    _ = lambda x:x

    94

    return [_("User-defined POUs"), _("Functions"), _("Function Blocks"), 

    95

            _("Programs"), _("Data Types"), _("Transitions"), _("Actions"), 

    96

            _("Configurations"), _("Resources"), _("Properties")]

    97

UNEDITABLE_NAMES = GetUneditableNames()

    98

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS, 

    99

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS, 

   100

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   101

   102

#-------------------------------------------------------------------------------

   103

#                 Helpers object for generating pou var list

   104

#-------------------------------------------------------------------------------

   105

   106

def compute_dimensions(el):

   107

    return [

   108

        (dimension.get("lower"), dimension.get("upper"))

   109

        for dimension in el.findall("dimension")]

   110

   111

def extract_param(el):

   112

    if el.tag == "Type" and el.text is None:

   113

        array = el.find("array")

   114

        return ('array', array.text, compute_dimensions(array))

   115

    elif el.tag == "Tree":

   116

        return generate_var_tree(el)

   117

    elif el.tag == "Edit":

   118

        return True

   119

    elif el.text is None:

   120

        return ''

   121

    return el.text

   122

   123

def generate_var_tree(tree):

   124

    return ([

   125

        (var.get("name"), var.text, generate_var_tree(var))

   126

         for var in tree.findall("var")],

   127

        compute_dimensions(tree))

   128

   129

class AddVariable(etree.XSLTExtension):

   130

   131

    def __init__(self, variables):

   132

        etree.XSLTExtension.__init__(self)

   133

        self.Variables = variables

   134

   135

    def execute(self, context, self_node, input_node, output_parent):

   136

        infos = etree.Element('var_infos')

   137

        self.process_children(context, infos)

   138

        self.Variables.append(

   139

            {el.tag.replace("_", " "): extract_param(el) for el in infos})

   140

   141

class VarTree(etree.XSLTExtension):

   142

   143

    def __init__(self, controller):

   144

        etree.XSLTExtension.__init__(self)

   145

        self.Controller = controller

   146

   147

    def execute(self, context, self_node, input_node, output_parent):

   148

        typename = input_node.get("name")

   149

        pou_infos = self.Controller.GetPou(typename)

   150

        if pou_infos is not None:

   151

            self.apply_templates(context, pou_infos, output_parent)

   152

            return

   153

   154

        datatype_infos = self.Controller.GetDataType(typename)

   155

        if datatype_infos is not None:

   156

            self.apply_templates(context, datatype_infos, output_parent)

   157

            return

   158

   159

variables_infos_xslt = etree.parse(

   160

    os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"))

   161

   162

#-------------------------------------------------------------------------------

   231

#                         Undo Buffer for PLCOpenEditor

   232

#-------------------------------------------------------------------------------

   233

   234

# Length of the buffer

   235

UNDO_BUFFER_LENGTH = 20

   236

   237

"""

   238

Class implementing a buffer of changes made on the current editing model

   239

"""

   240

class UndoBuffer:

   241

   242

    # Constructor initialising buffer

   243

    def __init__(self, currentstate, issaved = False):

   244

        self.Buffer = []

   245

        self.CurrentIndex = -1

   246

        self.MinIndex = -1

   247

        self.MaxIndex = -1

   248

        # if current state is defined

   249

        if currentstate:

   250

            self.CurrentIndex = 0

   251

            self.MinIndex = 0

   252

            self.MaxIndex = 0

   253

        # Initialising buffer with currentstate at the first place

   254

        for i in xrange(UNDO_BUFFER_LENGTH):

   255

            if i == 0:

   256

                self.Buffer.append(currentstate)

   257

            else:

   258

                self.Buffer.append(None)

   259

        # Initialising index of state saved

   260

        if issaved:

   261

            self.LastSave = 0

   262

        else:

   263

            self.LastSave = -1

   264

   265

    # Add a new state in buffer

   266

    def Buffering(self, currentstate):

   267

        self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH

   268

        self.Buffer[self.CurrentIndex] = currentstate

   269

        # Actualising buffer limits

   270

        self.MaxIndex = self.CurrentIndex

   271

        if self.MinIndex == self.CurrentIndex:

   272

            # If the removed state was the state saved, there is no state saved in the buffer

   273

            if self.LastSave == self.MinIndex:

   274

                self.LastSave = -1

   275

            self.MinIndex = (self.MinIndex + 1) % UNDO_BUFFER_LENGTH

   276

        self.MinIndex = max(self.MinIndex, 0)

   277

   278

    # Return current state of buffer

   279

    def Current(self):

   280

        return self.Buffer[self.CurrentIndex]

   281

   282

    # Change current state to previous in buffer and return new current state

   283

    def Previous(self):

   284

        if self.CurrentIndex != self.MinIndex:

   285

            self.CurrentIndex = (self.CurrentIndex - 1) % UNDO_BUFFER_LENGTH

   286

            return self.Buffer[self.CurrentIndex]

   287

        return None

   288

   289

    # Change current state to next in buffer and return new current state

   290

    def Next(self):

   291

        if self.CurrentIndex != self.MaxIndex:

   292

            self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH

   293

            return self.Buffer[self.CurrentIndex]

   294

        return None

   295

   296

    # Return True if current state is the first in buffer

   297

    def IsFirst(self):

   298

        return self.CurrentIndex == self.MinIndex

   299

   300

    # Return True if current state is the last in buffer

   301

    def IsLast(self):

   302

        return self.CurrentIndex == self.MaxIndex

   303

   304

    # Note that current state is saved

   305

    def CurrentSaved(self):

   306

        self.LastSave = self.CurrentIndex

   307

   308

    # Return True if current state is saved

   309

    def IsCurrentSaved(self):

   310

        return self.LastSave == self.CurrentIndex

   311

   312

   313

#-------------------------------------------------------------------------------

   314

#                           Controler for PLCOpenEditor

   315

#-------------------------------------------------------------------------------

   316

   317

"""

   318

Class which controls the operations made on the plcopen model and answers to view requests

   319

"""

   320

class PLCControler:

   321

   322

    # Create a new PLCControler

   323

    def __init__(self):

   324

        self.LastNewIndex = 0

   325

        self.Reset()

   326

   327

    # Reset PLCControler internal variables

   328

    def Reset(self):

   329

        self.Project = None

   330

        self.ProjectBufferEnabled = True

   331

        self.ProjectBuffer = None

   332

        self.ProjectSaved = True

   333

        self.Buffering = False

   334

        self.FilePath = ""

   335

        self.FileName = ""

   336

        self.ProgramChunks = []

   337

        self.ProgramOffset = 0

   338

        self.NextCompiledProject = None

   339

        self.CurrentCompiledProject = None

   340

        self.ConfNodeTypes = []

   341

        self.TotalTypesDict = StdBlckDct.copy()

   342

        self.TotalTypes = StdBlckLst[:]

   343

        self.ProgramFilePath = ""

   344

   345

    def GetQualifierTypes(self):

   346

        return QualifierList

   347

   348

    def GetProject(self, debug = False):

   349

        if debug and self.CurrentCompiledProject is not None:

   350

            return self.CurrentCompiledProject

   351

        else:

   352

            return self.Project

   353

   354

#-------------------------------------------------------------------------------

   355

#                         Project management functions

   356

#-------------------------------------------------------------------------------

   357

   358

    # Return if a project is opened

   359

    def HasOpenedProject(self):

   360

        return self.Project is not None

   361

   362

    # Create a new project by replacing the current one

   363

    def CreateNewProject(self, properties):

   364

        # Create the project

   365

        self.Project = PLCOpenParser.CreateRoot()

   366

        properties["creationDateTime"] = datetime.datetime(*localtime()[:6])

   367

        self.Project.setfileHeader(properties)

   368

        self.Project.setcontentHeader(properties)

   369

        self.SetFilePath("")

   370

   371

        # Initialize the project buffer

   372

        self.CreateProjectBuffer(False)

   373

        self.ProgramChunks = []

   374

        self.ProgramOffset = 0

   375

        self.NextCompiledProject = self.Copy(self.Project)

   376

        self.CurrentCompiledProject = None

   377

        self.Buffering = False

   378

   379

    # Return project data type names

   380

    def GetProjectDataTypeNames(self, debug = False):

   381

        project = self.GetProject(debug)

   382

        if project is not None:

   383

            return [datatype.getname() for datatype in project.getdataTypes()]

   384

        return []

   385

   386

    # Return project pou names

   387

    def GetProjectPouNames(self, debug = False):

   388

        project = self.GetProject(debug)

   389

        if project is not None:

   390

            return [pou.getname() for pou in project.getpous()]

   391

        return []

   392

   393

    # Return project pou names

   394

    def GetProjectConfigNames(self, debug = False):

   395

        project = self.GetProject(debug)

   396

        if project is not None:

   397

            return [config.getname() for config in project.getconfigurations()]

   398

        return []

   399

   400

    # Return project pou variable names

   401

    def GetProjectPouVariableNames(self, pou_name = None, debug = False):

   402

        variables = []

   403

        project = self.GetProject(debug)

   404

        if project is not None:

   405

            for pou in project.getpous():

   406

                if pou_name is None or pou_name == pou.getname():

   407

                    variables.extend([var["Name"] for var in self.GetPouInterfaceVars(pou, debug)])

   408

                    for transition in pou.gettransitionList():

   409

                        variables.append(transition.getname())

   410

                    for action in pou.getactionList():

   411

                        variables.append(action.getname())

   412

        return variables

   413

   414

    # Return file path if project is an open file

   415

    def GetFilePath(self):

   416

        return self.FilePath

   417

   418

    # Return file path if project is an open file

   419

    def GetProgramFilePath(self):

   420

        return self.ProgramFilePath

   421

   422

    # Return file name and point out if file is up to date

   423

    def GetFilename(self):

   424

        if self.Project is not None:

   425

            if self.ProjectIsSaved():

   426

                return self.FileName

   427

            else:

   428

                return "~%s~"%self.FileName

   429

        return ""

   430

   431

    # Change file path and save file name or create a default one if file path not defined

   432

    def SetFilePath(self, filepath):

   433

        self.FilePath = filepath

   434

        if filepath == "":

   435

            self.LastNewIndex += 1

   436

            self.FileName = _("Unnamed%d")%self.LastNewIndex

   437

        else:

   438

            self.FileName = os.path.splitext(os.path.basename(filepath))[0]

   439

   440

    # Change project properties

   441

    def SetProjectProperties(self, name = None, properties = None, buffer = True):

   442

        if self.Project is not None:

   443

            if name is not None:

   444

                self.Project.setname(name)

   445

            if properties is not None:

   446

                self.Project.setfileHeader(properties)

   447

                self.Project.setcontentHeader(properties)

   448

            if buffer and (name is not None or properties is not None):

   449

                self.BufferProject()

   450

   451

    # Return project name

   452

    def GetProjectName(self, debug=False):

   453

        project = self.GetProject(debug)

   454

        if project is not None:

   455

            return project.getname()

   456

        return None

   457

   458

    # Return project properties

   459

    def GetProjectProperties(self, debug = False):

   460

        project = self.GetProject(debug)

   461

        if project is not None:

   462

            properties = project.getfileHeader()

   463

            properties.update(project.getcontentHeader())

   464

            return properties

   465

        return None

   466

   467

    # Return project informations

   468

    def GetProjectInfos(self, debug = False):

   469

        project = self.GetProject(debug)

   470

        if project is not None:

   471

            infos = {"name": project.getname(), "type": ITEM_PROJECT}

   472

            datatypes = {"name": DATA_TYPES, "type": ITEM_DATATYPES, "values":[]}

   473

            for datatype in project.getdataTypes():

   474

                datatypes["values"].append({"name": datatype.getname(), "type": ITEM_DATATYPE, 

   475

                    "tagname": self.ComputeDataTypeName(datatype.getname()), "values": []})

   476

            pou_types = {"function": {"name": FUNCTIONS, "type": ITEM_FUNCTION, "values":[]},

   477

                         "functionBlock": {"name": FUNCTION_BLOCKS, "type": ITEM_FUNCTIONBLOCK, "values":[]},

   478

                         "program": {"name": PROGRAMS, "type": ITEM_PROGRAM, "values":[]}}

   479

            for pou in project.getpous():

   480

                pou_type = pou.getpouType()

   481

                pou_infos = {"name": pou.getname(), "type": ITEM_POU,

   482

                             "tagname": self.ComputePouName(pou.getname())}

   483

                pou_values = []

   484

                if pou.getbodyType() == "SFC":

   485

                    transitions = []

   486

                    for transition in pou.gettransitionList():

   487

                        transitions.append({"name": transition.getname(), "type": ITEM_TRANSITION, 

   488

                            "tagname": self.ComputePouTransitionName(pou.getname(), transition.getname()), 

   489

                            "values": []})

   490

                    pou_values.append({"name": TRANSITIONS, "type": ITEM_TRANSITIONS, "values": transitions})

   491

                    actions = []

   492

                    for action in pou.getactionList():

   493

                        actions.append({"name": action.getname(), "type": ITEM_ACTION, 

   494

                            "tagname": self.ComputePouActionName(pou.getname(), action.getname()), 

   495

                            "values": []})

   496

                    pou_values.append({"name": ACTIONS, "type": ITEM_ACTIONS, "values": actions})

   497

                if pou_type in pou_types:

   498

                    pou_infos["values"] = pou_values

   499

                    pou_types[pou_type]["values"].append(pou_infos)

   500

            configurations = {"name": CONFIGURATIONS, "type": ITEM_CONFIGURATIONS, "values": []}

   501

            for config in project.getconfigurations():

   502

                config_name = config.getname()

   503

                config_infos = {"name": config_name, "type": ITEM_CONFIGURATION, 

   504

                    "tagname": self.ComputeConfigurationName(config.getname()), 

   505

                    "values": []}

   506

                resources = {"name": RESOURCES, "type": ITEM_RESOURCES, "values": []}

   507

                for resource in config.getresource():

   508

                    resource_name = resource.getname()

   509

                    resource_infos = {"name": resource_name, "type": ITEM_RESOURCE, 

   510

                        "tagname": self.ComputeConfigurationResourceName(config.getname(), resource.getname()), 

   511

                        "values": []}

   512

                    resources["values"].append(resource_infos)

   513

                config_infos["values"] = [resources]

   514

                configurations["values"].append(config_infos)

   515

            infos["values"] = [datatypes, pou_types["function"], pou_types["functionBlock"], 

   516

                               pou_types["program"], configurations]

   517

            return infos

   518

        return None