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

from collections import OrderedDict, namedtuple

    33

    34

from plcopen import *

    35

from graphics.GraphicCommons import *

    36

from PLCGenerator import *

    37

    38

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)?")

    39

    40

ITEMS_EDITABLE = [ITEM_PROJECT,

    41

                  ITEM_POU,

    42

                  ITEM_VARIABLE,

    43

                  ITEM_TRANSITION,

    44

                  ITEM_ACTION,

    45

                  ITEM_CONFIGURATION,

    46

                  ITEM_RESOURCE,

    47

                  ITEM_DATATYPE

    48

                 ] = range(8)

    49

    50

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    51

                    ITEM_FUNCTION,

    52

                    ITEM_FUNCTIONBLOCK,

    53

                    ITEM_PROGRAM,

    54

                    ITEM_TRANSITIONS,

    55

                    ITEM_ACTIONS,

    56

                    ITEM_CONFIGURATIONS,

    57

                    ITEM_RESOURCES,

    58

                    ITEM_PROPERTIES

    59

                   ] = range(8, 17)

    60

    61

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    62

                  ITEM_VAR_GLOBAL,

    63

                  ITEM_VAR_EXTERNAL,

    64

                  ITEM_VAR_TEMP,

    65

                  ITEM_VAR_INPUT,

    66

                  ITEM_VAR_OUTPUT,

    67

                  ITEM_VAR_INOUT

    68

                 ] = range(17, 24)

    69

    70

VAR_CLASS_INFOS = {

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

    79

POU_TYPES = {"program": ITEM_PROGRAM,

    80

             "functionBlock": ITEM_FUNCTIONBLOCK,

    81

             "function": ITEM_FUNCTION,

    82

            }

    83

    84

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    85

                   LOCATION_MODULE,

    86

                   LOCATION_GROUP,

    87

                   LOCATION_VAR_INPUT,

    88

                   LOCATION_VAR_OUTPUT,

    89

                   LOCATION_VAR_MEMORY] = range(6)

    90

    91

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

    92

    93

def GetUneditableNames():

    94

    _ = lambda x:x

    95

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

    96

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

    97

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

    98

UNEDITABLE_NAMES = GetUneditableNames()

    99

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS, 

   100

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS, 

   101

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   102

   103

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

   104

#                 Helper object for loading library in xslt stylesheets

   105

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

   106

   107

class LibraryResolver(etree.Resolver):

   108

   109

    def __init__(self, controller, debug=False):

   110

        self.Controller = controller

   111

        self.Debug = debug

   112

   113

    def resolve(self, url, pubid, context):

   114

        lib_name = os.path.basename(url)

   115

        if lib_name in ["project", "stdlib", "extensions"]:

   116

            lib_el = etree.Element(lib_name)

   117

            if lib_name == "project":

   118

                lib_el.append(deepcopy(self.Controller.GetProject(self.Debug)))

   119

            elif lib_name == "stdlib":

   120

                for lib in [StdBlockLibrary, AddnlBlockLibrary]:

   121

                    lib_el.append(deepcopy(lib))

   122

            else:

   123

                for ctn in self.Controller.ConfNodeTypes:

   124

                    lib_el.append(deepcopy(ctn["types"]))

   125

            return self.resolve_string(etree.tostring(lib_el), context)

   126

   127

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

   128

#           Helpers functions for translating list of arguments

   129

#                       from xslt to valid arguments

   130

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

   131

   132

_BoolValue = lambda x: x in ["true", "0"]

   133

   134

def _translate_args(translations, args):

   135

    return [translate(arg[0]) if len(arg) > 0 else None 

   136

            for translate, arg in

   137

            zip(translations, args)]

   138

   139

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

   140

#                 Helpers object for generating pou var list

   141

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

   142

   143

class _VariableInfos(object):

   144

    __slots__ = ["Name", "Class", "Option", "Location", "InitialValue", 

   145

                 "Edit", "Documentation", "Type", "Tree", "Number"]

   146

    def __init__(self, *args):

   147

        for attr, value in zip(self.__slots__, args):

   148

            setattr(self, attr, value if value is not None else "")

   149

    def copy(self):

   150

        return _VariableInfos(*[getattr(self, attr) for attr in self.__slots__])

   151

   152

class VariablesInfosFactory:

   153

   154

    def __init__(self, variables):

   155

        self.Variables = variables

   156

        self.TreeStack = []

   157

        self.Type = None

   158

        self.Dimensions = None

   159

   160

    def SetType(self, context, *args):

   161

        self.Type = args[0][0]

   162

   163

    def GetType(self):

   164

        if len(self.Dimensions) > 0:

   165

            return ("array", self.Type, self.Dimensions)

   166

        return self.Type

   167

   168

    def GetTree(self):

   169

        return (self.TreeStack.pop(-1), self.Dimensions)

   170

   171

    def AddDimension(self, context, *args):

   172

        self.Dimensions.append(tuple(

   173

            _translate_args([str] * 2, args)))

   174

   175

    def AddTree(self, context, *args):

   176

        self.TreeStack.append([])

   177

        self.Dimensions = []

   178

   179

    def AddVarToTree(self, context, *args):

   180

        var = (args[0][0], self.Type, self.GetTree())

   181

        self.TreeStack[-1].append(var)

   182

   183

    def AddVariable(self, context, *args):

   184

        self.Variables.append(_VariableInfos(*(_translate_args(

   185

            [str] * 5 + [_BoolValue] + [str], args) + 

   186

            [self.GetType(), self.GetTree()])))

   187

   188

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

   189

#            Helpers object for generating pou variable instance list

   190

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

   191

   192

def class_extraction(value):

   193

    class_type = {

   194

        "configuration": ITEM_CONFIGURATION,

   195

        "resource": ITEM_RESOURCE,

   196

        "action": ITEM_ACTION,

   197

        "transition": ITEM_TRANSITION,

   198

        "program": ITEM_PROGRAM}.get(value)

   199

    if class_type is not None:

   200

        return class_type

   201

   202

    pou_type = POU_TYPES.get(value)

   203

    if pou_type is not None:

   204

        return pou_type

   205

   206

    var_type = VAR_CLASS_INFOS.get(value)

   207

    if var_type is not None:

   208

        return var_type[1]

   209

   210

    return None

   211

   212

class _VariablesTreeItemInfos(object):

   213

    __slots__ = ["name", "var_class", "type", "edit", "debug", "variables"]

   214

    def __init__(self, *args):

   215

        for attr, value in zip(self.__slots__, args):

   216

            setattr(self, attr, value if value is not None else "")

   217

    def copy(self):

   218

        return _VariableTreeItem(*[getattr(self, attr) for attr in self.__slots__])

   219

   220

class VariablesTreeInfosFactory:

   221

   222

    def __init__(self):

   223

        self.Root = None

   224

   225

    def GetRoot(self):

   226

        return self.Root

   227

   228

    def SetRoot(self, context, *args):

   229

        self.Root = _VariablesTreeItemInfos(

   230

            *([''] + _translate_args(

   231

                [class_extraction, str] + [_BoolValue] * 2, 

   232

                args) + [[]]))

   233

   234

    def AddVariable(self, context, *args):

   235

        if self.Root is not None:

   236

            self.Root.variables.append(_VariablesTreeItemInfos(

   237

                *(_translate_args(

   238

                    [str, class_extraction, str] + [_BoolValue] * 2, 

   239

                    args) + [[]])))

   240

   241

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

   242

#            Helpers object for generating instances path list

   243

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

   244

   245

class InstancesPathFactory:

   246

   247

    def __init__(self, instances):

   248

        self.Instances = instances

   249

   250

    def AddInstance(self, context, *args):

   251

        self.Instances.append(args[0][0])

   252

   253

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

   254

#            Helpers object for generating instance tagname

   255

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

   256

   258

   259

    def __init__(self, controller):

   260

        self.Controller = controller

   281

   282

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

   283

#           Helpers object for generating pou block instances list

   284

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

   285

   286

_Point = namedtuple("Point", ["x", "y"])

   287

   288

_BlockInstanceInfos = namedtuple("BlockInstanceInfos", 

   289

    ["type", "id", "x", "y", "width", "height", "specific_values", "inputs", "outputs"])

   290

   291

_BlockSpecificValues = (

   292

    namedtuple("BlockSpecificValues", 

   293

               ["name", "execution_order"]),

   294

    [str, int])

   295

_VariableSpecificValues = (

   296

    namedtuple("VariableSpecificValues", 

   297

               ["name", "value_type", "execution_order"]),

   298

    [str, str, int])

   299

_ConnectionSpecificValues = (

   300

    namedtuple("ConnectionSpecificValues", ["name"]),

   301

    [str])

   302

   303

_PowerRailSpecificValues = (

   304

    namedtuple("PowerRailSpecificValues", ["connectors"]),

   305

    [int])

   306

   307

_LDElementSpecificValues = (

   308

    namedtuple("LDElementSpecificValues", 

   309

               ["name", "negated", "edge", "storage", "execution_order"]),

   310

    [str, _BoolValue, str, str, int])

   311

   312

_DivergenceSpecificValues = (

   313

    namedtuple("DivergenceSpecificValues", ["connectors"]),

   314

    [int])

   315

   316

_SpecificValuesTuples = {

   317

    "comment": (

   318

        namedtuple("CommentSpecificValues", ["content"]),

   319

        [str]),

   320

    "input": _VariableSpecificValues,

   321

    "output": _VariableSpecificValues,

   322

    "inout": _VariableSpecificValues,

   323

    "connector": _ConnectionSpecificValues,

   324

    "continuation": _ConnectionSpecificValues,

   325

    "leftPowerRail": _PowerRailSpecificValues,

   326

    "rightPowerRail": _PowerRailSpecificValues,

   327

    "contact": _LDElementSpecificValues,

   328

    "coil": _LDElementSpecificValues,

   329

    "step": (

   330

        namedtuple("StepSpecificValues", ["name", "initial", "action"]),

   331

        [str, _BoolValue, lambda x: x]),

   332

    "transition": (

   333

        namedtuple("TransitionSpecificValues", 

   334

                   ["priority", "condition_type", "condition", "connection"]),

   335

        [int, str, str, lambda x: x]),

   336

    "selectionDivergence": _DivergenceSpecificValues,

   337

    "selectionConvergence": _DivergenceSpecificValues,

   338

    "simultaneousDivergence": _DivergenceSpecificValues,

   339

    "simultaneousConvergence": _DivergenceSpecificValues,

   340

    "jump": (

   341

        namedtuple("JumpSpecificValues", ["target"]),

   342

        [str]),

   343

    "actionBlock": (

   344

        namedtuple("ActionBlockSpecificValues", ["actions"]),

   345

        [lambda x: x]),

   346

}

   347

   348

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   349

    ["name", "negated", "edge", "position", "links"])

   350

   351

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   352

    ["refLocalId", "formalParameter", "points"])

   353

   354

class _ActionInfos(object):

   355

    __slots__ = ["qualifier", "type", "value", "duration", "indicator"]

   356

    def __init__(self, *args):

   357

        for attr, value in zip(self.__slots__, args):

   358

            setattr(self, attr, value if value is not None else "")

   359

    def copy(self):

   360

        return _ActionInfos(*[getattr(self, attr) for attr in self.__slots__])

   361

   362

class BlockInstanceFactory:

   363

   364

    def __init__(self, block_instances):

   365

        self.BlockInstances = block_instances

   366

        self.CurrentInstance = None

   367

        self.SpecificValues = None

   368

        self.CurrentConnection = None

   369

        self.CurrentLink = None

   370

   371

    def SetSpecificValues(self, context, *args):

   372

        self.SpecificValues = list(args)

   373

        self.CurrentInstance = None

   374

        self.CurrentConnection = None

   375

        self.CurrentLink = None

   376

   377

    def AddBlockInstance(self, context, *args):

   378

        specific_values_tuple, specific_values_translation = \

   379

            _SpecificValuesTuples.get(args[0][0], _BlockSpecificValues)

   380

   381

        if (args[0][0] == "step" and len(self.SpecificValues) < 3 or

   382

            args[0][0] == "transition" and len(self.SpecificValues) < 4):

   383

            self.SpecificValues.append([None])

   384

        elif args[0][0] == "actionBlock" and len(self.SpecificValues) < 1:

   385

            self.SpecificValues.append([[]])

   386

        specific_values = specific_values_tuple(*_translate_args(

   387

            specific_values_translation, self.SpecificValues))

   388

        self.SpecificValues = None

   389

   390

        self.CurrentInstance = _BlockInstanceInfos(

   391

            *(_translate_args([str] + [int] * 5, args) + 

   392

              [specific_values, [], []]))

   393

   394

        self.BlockInstances[self.CurrentInstance.id] = self.CurrentInstance

   395

   396

    def AddInstanceConnection(self, context, *args):

   397

        connection_args = _translate_args(

   398

            [str, str, _BoolValue, str, int, int], args)

   399

   400

        self.CurrentConnection = _InstanceConnectionInfos(

   401

            *(connection_args[1:4] + [

   402

                _Point(*connection_args[4:6]), []]))

   403

   404

        if self.CurrentInstance is not None:

   405

            if connection_args[0] == "input":

   406

                self.CurrentInstance.inputs.append(self.CurrentConnection)

   407

            else:

   408

                self.CurrentInstance.outputs.append(self.CurrentConnection)

   409

        else:

   410

            self.SpecificValues.append([self.CurrentConnection])

   411

   412

    def AddConnectionLink(self, context, *args):

   413

        self.CurrentLink = _ConnectionLinkInfos(

   414

            *(_translate_args([int, str], args) + [[]]))

   415

        self.CurrentConnection.links.append(self.CurrentLink)

   416

   417

    def AddLinkPoint(self, context, *args):

   418

        self.CurrentLink.points.append(_Point(

   419

            *_translate_args([int, int], args)))

   420

   421

    def AddAction(self, context, *args):

   422

        if len(self.SpecificValues) == 0:

   423

            self.SpecificValues.append([[]])

   424

        translated_args = _translate_args([str] * 5, args)

   425

        self.SpecificValues[0][0].append(_ActionInfos(*translated_args))

   426

   427

pou_block_instances_xslt = etree.parse(

   428

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

   429

   430

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

   431

#                         Undo Buffer for PLCOpenEditor

   432

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

   433

   434

# Length of the buffer

   435

UNDO_BUFFER_LENGTH = 20

   436

   437

"""

   438

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

   439

"""

   440

class UndoBuffer:

   441

   442

    # Constructor initialising buffer

   443

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

   444

        self.Buffer = []

   445

        self.CurrentIndex = -1

   446

        self.MinIndex = -1

   447

        self.MaxIndex = -1

   448

        # if current state is defined

   449

        if currentstate:

   450

            self.CurrentIndex = 0

   451

            self.MinIndex = 0

   452

            self.MaxIndex = 0

   453

        # Initialising buffer with currentstate at the first place

   454

        for i in xrange(UNDO_BUFFER_LENGTH):

   455

            if i == 0:

   456

                self.Buffer.append(currentstate)

   457

            else:

   458

                self.Buffer.append(None)

   459

        # Initialising index of state saved

   460

        if issaved:

   461

            self.LastSave = 0

   462

        else:

   463

            self.LastSave = -1

   464

   465

    # Add a new state in buffer

   466

    def Buffering(self, currentstate):

   467

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

   468

        self.Buffer[self.CurrentIndex] = currentstate

   469

        # Actualising buffer limits

   470

        self.MaxIndex = self.CurrentIndex

   471

        if self.MinIndex == self.CurrentIndex:

   472

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

   473

            if self.LastSave == self.MinIndex:

   474

                self.LastSave = -1

   475

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

   476

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

   477

   478

    # Return current state of buffer

   479

    def Current(self):

   480

        return self.Buffer[self.CurrentIndex]

   481

   482

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

   483

    def Previous(self):

   484

        if self.CurrentIndex != self.MinIndex:

   485

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

   486

            return self.Buffer[self.CurrentIndex]

   487

        return None

   488

   489

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

   490

    def Next(self):

   491

        if self.CurrentIndex != self.MaxIndex:

   492

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

   493

            return self.Buffer[self.CurrentIndex]

   494

        return None

   495

   496

    # Return True if current state is the first in buffer

   497

    def IsFirst(self):

   498

        return self.CurrentIndex == self.MinIndex

   499

   500

    # Return True if current state is the last in buffer

   501

    def IsLast(self):

   502

        return self.CurrentIndex == self.MaxIndex

   503

   504

    # Note that current state is saved

   505

    def CurrentSaved(self):