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

   257

class InstanceTagName:

   258

   259

    def __init__(self, controller):

   260

        self.Controller = controller

   261

        self.TagName = None

   262

   263

    def GetTagName(self):

   264

        return self.TagName

   265

   266

    def ConfigTagName(self, context, *args):

   267

        self.TagName = self.Controller.ComputeConfigurationName(args[0][0])

   268

   269

    def ResourceTagName(self, context, *args):

   270

        self.TagName = self.Controller.ComputeConfigurationResourceName(args[0][0], args[1][0])

   271

   272

    def PouTagName(self, context, *args):

   273

        self.TagName = self.Controller.ComputePouName(args[0][0])

   274

   275

    def ActionTagName(self, context, *args):

   276

        self.TagName = self.Controller.ComputePouActionName(args[0][0], args[0][1])

   277

   278

    def TransitionTagName(self, context, *args):

   279

        self.TagName = self.Controller.ComputePouTransitionName(args[0][0], args[0][1])

   280

   281

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

   282

#           Helpers object for generating pou block instances list

   283

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

   284

   285

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

   286

   287

_BlockInstanceInfos = namedtuple("BlockInstanceInfos", 

   288

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

   289

   290

_BlockSpecificValues = (

   291

    namedtuple("BlockSpecificValues", 

   292

               ["name", "execution_order"]),

   293

    [str, int])

   294

_VariableSpecificValues = (

   295

    namedtuple("VariableSpecificValues", 

   296

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

   297

    [str, str, int])

   298

_ConnectionSpecificValues = (

   299

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

   300

    [str])

   301

   302

_PowerRailSpecificValues = (

   303

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

   304

    [int])

   305

   306

_LDElementSpecificValues = (

   307

    namedtuple("LDElementSpecificValues", 

   308

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

   309

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

   310

   311

_DivergenceSpecificValues = (

   312

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

   313

    [int])

   314

   315

_SpecificValuesTuples = {

   316

    "comment": (

   317

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

   318

        [str]),

   319

    "input": _VariableSpecificValues,

   320

    "output": _VariableSpecificValues,

   321

    "inout": _VariableSpecificValues,

   322

    "connector": _ConnectionSpecificValues,

   323

    "continuation": _ConnectionSpecificValues,

   324

    "leftPowerRail": _PowerRailSpecificValues,

   325

    "rightPowerRail": _PowerRailSpecificValues,

   326

    "contact": _LDElementSpecificValues,

   327

    "coil": _LDElementSpecificValues,

   328

    "step": (

   329

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

   330

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

   331

    "transition": (

   332

        namedtuple("TransitionSpecificValues", 

   333

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

   334

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

   335

    "selectionDivergence": _DivergenceSpecificValues,

   336

    "selectionConvergence": _DivergenceSpecificValues,

   337

    "simultaneousDivergence": _DivergenceSpecificValues,

   338

    "simultaneousConvergence": _DivergenceSpecificValues,

   339

    "jump": (

   340

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

   341

        [str]),

   342

    "actionBlock": (

   343

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

   344

        [lambda x: x]),

   345

}

   346

   347

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   348

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

   349

   350

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   351

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

   352

   353

class _ActionInfos(object):

   354

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

   355

    def __init__(self, *args):

   356

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

   357

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

   358

    def copy(self):

   359

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

   360

   361

class BlockInstanceFactory:

   362

   363

    def __init__(self, block_instances):

   364

        self.BlockInstances = block_instances

   365

        self.CurrentInstance = None

   366

        self.SpecificValues = None

   367

        self.CurrentConnection = None

   368

        self.CurrentLink = None

   369

   370

    def SetSpecificValues(self, context, *args):

   371

        self.SpecificValues = list(args)

   372

        self.CurrentInstance = None

   373

        self.CurrentConnection = None

   374

        self.CurrentLink = None

   375

   376

    def AddBlockInstance(self, context, *args):

   377

        specific_values_tuple, specific_values_translation = \

   378

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

   379

   380

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

   381

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

   382

            self.SpecificValues.append([None])

   383

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

   384

            self.SpecificValues.append([[]])

   385

        specific_values = specific_values_tuple(*_translate_args(

   386

            specific_values_translation, self.SpecificValues))

   387

        self.SpecificValues = None

   388

   389

        self.CurrentInstance = _BlockInstanceInfos(

   390

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

   391

              [specific_values, [], []]))

   392

   393

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

   394

   395

    def AddInstanceConnection(self, context, *args):

   396

        connection_args = _translate_args(

   397

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

   398

   399

        self.CurrentConnection = _InstanceConnectionInfos(

   400

            *(connection_args[1:4] + [

   401

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

   402

   403

        if self.CurrentInstance is not None:

   404

            if connection_args[0] == "input":

   405

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

   406

            else:

   407

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

   408

        else:

   409

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

   410

   411

    def AddConnectionLink(self, context, *args):

   412

        self.CurrentLink = _ConnectionLinkInfos(

   413

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

   414

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

   415

   416

    def AddLinkPoint(self, context, *args):

   417

        self.CurrentLink.points.append(_Point(

   418

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

   419

   420

    def AddAction(self, context, *args):

   421

        if len(self.SpecificValues) == 0:

   422

            self.SpecificValues.append([[]])

   423

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

   424

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

   425

   426

pou_block_instances_xslt = etree.parse(

   427

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

   428

   429

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

   430

#                         Undo Buffer for PLCOpenEditor

   431

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

   432

   433

# Length of the buffer

   434

UNDO_BUFFER_LENGTH = 20

   435

   436

"""

   437

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

   438

"""

   439

class UndoBuffer:

   440

   441

    # Constructor initialising buffer

   442

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

   443

        self.Buffer = []

   444

        self.CurrentIndex = -1

   445

        self.MinIndex = -1

   446

        self.MaxIndex = -1

   447

        # if current state is defined

   448

        if currentstate:

   449

            self.CurrentIndex = 0

   450

            self.MinIndex = 0

   451

            self.MaxIndex = 0

   452

        # Initialising buffer with currentstate at the first place

   453

        for i in xrange(UNDO_BUFFER_LENGTH):

   454

            if i == 0:

   455

                self.Buffer.append(currentstate)

   456

            else:

   457

                self.Buffer.append(None)

   458

        # Initialising index of state saved

   459

        if issaved:

   460

            self.LastSave = 0

   461

        else:

   462

            self.LastSave = -1

   463

   464

    # Add a new state in buffer

   465

    def Buffering(self, currentstate):

   466

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

   467

        self.Buffer[self.CurrentIndex] = currentstate

   468

        # Actualising buffer limits

   469

        self.MaxIndex = self.CurrentIndex

   470

        if self.MinIndex == self.CurrentIndex:

   471

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

   472

            if self.LastSave == self.MinIndex:

   473

                self.LastSave = -1

   474

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

   475

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

   476

   477

    # Return current state of buffer

   478

    def Current(self):

   479

        return self.Buffer[self.CurrentIndex]

   480

   481

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

   482

    def Previous(self):

   483

        if self.CurrentIndex != self.MinIndex:

   484

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

   485

            return self.Buffer[self.CurrentIndex]

   486

        return None

   487

   488

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

   489

    def Next(self):

   490

        if self.CurrentIndex != self.MaxIndex:

   491

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

   492

            return self.Buffer[self.CurrentIndex]

   493

        return None

   494

   495

    # Return True if current state is the first in buffer

   496

    def IsFirst(self):

   497

        return self.CurrentIndex == self.MinIndex

   498

   499

    # Return True if current state is the last in buffer

   500

    def IsLast(self):

   501

        return self.CurrentIndex == self.MaxIndex

   502

   503

    # Note that current state is saved

   504

    def CurrentSaved(self):

   505

        self.LastSave = self.CurrentIndex