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

   252

   253

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

   254

#            Helpers object for generating instance tagname

   255

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

   256

   257

class InstanceTagName(etree.XSLTExtension):

   258

   259

    def __init__(self, controller):

   260

        etree.XSLTExtension.__init__(self)

   261

        self.Controller = controller

   262

   263

    def GetTagName(self, infos):

   264

        return ""

   265

   266

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

   267

        tagname_infos = etree.Element('infos')

   268

        self.process_children(context, tagname_infos)

   269

        tagname = etree.Element('tagname')

   270

        tagname.text = self.GetTagName(tagname_infos)

   271

        try:

   272

            output_parent.append(tagname)

   273

        except:

   274

            pass

   275

   276

class ConfigTagName(InstanceTagName):

   277

   278

    def GetTagName(self, infos):

   279

        return self.Controller.ComputeConfigurationName(infos.get("name"))

   280

   281

class ResourceTagName(InstanceTagName):

   282

   283

    def GetTagName(self, infos):

   284

        return self.Controller.ComputeConfigurationResourceName(

   285

            infos.get("config_name"), infos.get("name"))

   286

   287

class PouTagName(InstanceTagName):

   288

   289

    def GetTagName(self, infos):

   290

        return self.Controller.ComputePouName(infos.get("name"))

   291

   292

class ActionTagName(InstanceTagName):

   293

   294

    def GetTagName(self, infos):

   295

        return self.Controller.ComputePouActionName(

   296

            infos.get("pou_name"), infos.get("name"))

   297

   298

class TransitionTagName(InstanceTagName):

   299

   300

    def GetTagName(self, infos):

   301

        return self.Controller.ComputePouTransitionName(

   302

            infos.get("pou_name"), infos.get("name"))

   303

   304

instance_tagname_xslt = etree.parse(

   305

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

   306

   307

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

   308

#           Helpers object for generating pou block instances list

   309

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

   310

   311

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

   312

   313

_BlockInstanceInfos = namedtuple("BlockInstanceInfos", 

   314

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

   315

   316

_BlockSpecificValues = (

   317

    namedtuple("BlockSpecificValues", 

   318

               ["name", "execution_order"]),

   319

    [str, int])

   320

_VariableSpecificValues = (

   321

    namedtuple("VariableSpecificValues", 

   322

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

   323

    [str, str, int])

   324

_ConnectionSpecificValues = (

   325

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

   326

    [str])

   327

   328

_PowerRailSpecificValues = (

   329

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

   330

    [int])

   331

   332

_LDElementSpecificValues = (

   333

    namedtuple("LDElementSpecificValues", 

   334

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

   335

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

   336

   337

_DivergenceSpecificValues = (

   338

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

   339

    [int])

   340

   341

_SpecificValuesTuples = {

   342

    "comment": (

   343

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

   344

        [str]),

   345

    "input": _VariableSpecificValues,

   346

    "output": _VariableSpecificValues,

   347

    "inout": _VariableSpecificValues,

   348

    "connector": _ConnectionSpecificValues,

   349

    "continuation": _ConnectionSpecificValues,

   350

    "leftPowerRail": _PowerRailSpecificValues,

   351

    "rightPowerRail": _PowerRailSpecificValues,

   352

    "contact": _LDElementSpecificValues,

   353

    "coil": _LDElementSpecificValues,

   354

    "step": (

   355

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

   356

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

   357

    "transition": (

   358

        namedtuple("TransitionSpecificValues", 

   359

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

   360

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

   361

    "selectionDivergence": _DivergenceSpecificValues,

   362

    "selectionConvergence": _DivergenceSpecificValues,

   363

    "simultaneousDivergence": _DivergenceSpecificValues,

   364

    "simultaneousConvergence": _DivergenceSpecificValues,

   365

    "jump": (

   366

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

   367

        [str]),

   368

    "actionBlock": (

   369

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

   370

        [lambda x: x]),

   371

}

   372

   373

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   374

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

   375

   376

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   377

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

   378

   379

class _ActionInfos(object):

   380

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

   381

    def __init__(self, *args):

   382

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

   383

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

   384

    def copy(self):

   385

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

   386

   387

class BlockInstanceFactory:

   388

   389

    def __init__(self, block_instances):

   390

        self.BlockInstances = block_instances

   391

        self.CurrentInstance = None

   392

        self.SpecificValues = None

   393

        self.CurrentConnection = None

   394

        self.CurrentLink = None

   395

   396

    def SetSpecificValues(self, context, *args):

   397

        self.SpecificValues = list(args)

   398

        self.CurrentInstance = None

   399

        self.CurrentConnection = None

   400

        self.CurrentLink = None

   401

   402

    def AddBlockInstance(self, context, *args):

   403

        specific_values_tuple, specific_values_translation = \

   404

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

   405

   406

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

   407

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

   408

            self.SpecificValues.append([None])

   409

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

   410

            self.SpecificValues.append([[]])

   411

        specific_values = specific_values_tuple(*_translate_args(

   412

            specific_values_translation, self.SpecificValues))

   413

        self.SpecificValues = None

   414

   415

        self.CurrentInstance = _BlockInstanceInfos(

   416

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

   417

              [specific_values, [], []]))

   418

   419

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

   420

   421

    def AddInstanceConnection(self, context, *args):

   422

        connection_args = _translate_args(

   423

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

   424

   425

        self.CurrentConnection = _InstanceConnectionInfos(

   426

            *(connection_args[1:4] + [

   427

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

   428

   429

        if self.CurrentInstance is not None:

   430

            if connection_args[0] == "input":

   431

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

   432

            else:

   433

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

   434

        else:

   435

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

   436

   437

    def AddConnectionLink(self, context, *args):

   438

        self.CurrentLink = _ConnectionLinkInfos(

   439

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

   440

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

   441

   442

    def AddLinkPoint(self, context, *args):

   443

        self.CurrentLink.points.append(_Point(

   444

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

   445

   446

    def AddAction(self, context, *args):

   447

        if len(self.SpecificValues) == 0:

   448

            self.SpecificValues.append([[]])

   449

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

   450

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

   451

   452

pou_block_instances_xslt = etree.parse(

   453

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

   454

   455

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

   456

#                         Undo Buffer for PLCOpenEditor

   457

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

   458

   459

# Length of the buffer

   460

UNDO_BUFFER_LENGTH = 20

   461

   462

"""

   463

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

   464

"""

   465

class UndoBuffer:

   466

   467

    # Constructor initialising buffer

   468

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

   469

        self.Buffer = []

   470

        self.CurrentIndex = -1

   471

        self.MinIndex = -1

   472

        self.MaxIndex = -1

   473

        # if current state is defined

   474

        if currentstate:

   475

            self.CurrentIndex = 0

   476

            self.MinIndex = 0

   477

            self.MaxIndex = 0

   478

        # Initialising buffer with currentstate at the first place

   479

        for i in xrange(UNDO_BUFFER_LENGTH):

   480

            if i == 0:

   481

                self.Buffer.append(currentstate)

   482

            else:

   483

                self.Buffer.append(None)

   484

        # Initialising index of state saved

   485

        if issaved:

   486

            self.LastSave = 0

   487

        else:

   488

            self.LastSave = -1

   489

   490

    # Add a new state in buffer

   491

    def Buffering(self, currentstate):

   492

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

   493

        self.Buffer[self.CurrentIndex] = currentstate

   494

        # Actualising buffer limits

   495

        self.MaxIndex = self.CurrentIndex

   496

        if self.MinIndex == self.CurrentIndex:

   497

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

   498

            if self.LastSave == self.MinIndex:

   499

                self.LastSave = -1

   500

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

   501

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

   502

   503

    # Return current state of buffer