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":

   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

_StringValue = lambda x: x

   133

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

   134

   135

def _translate_args(translations, args):

   136

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

   137

            for translate, arg in

   138

            zip(translations, args)]

   139

   140

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

   141

#                 Helpers object for generating pou var list

   142

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

   143

   144

class _VariableInfos(object):

   145

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

   146

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

   147

    def __init__(self, *args):

   148

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

   149

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

   150

    def copy(self):

   151

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

   152

   153

class VariablesInfosFactory:

   154

   155

    def __init__(self, variables):

   156

        self.Variables = variables

   157

        self.TreeStack = []

   158

        self.Type = None

   159

        self.Dimensions = None

   160

   161

    def SetType(self, context, *args):

   162

        self.Type = args[0][0]

   163

   164

    def GetType(self):

   165

        if len(self.Dimensions) > 0:

   166

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

   167

        return self.Type

   168

   169

    def GetTree(self):

   170

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

   171

   172

    def AddDimension(self, context, *args):

   173

        self.Dimensions.append(tuple(

   174

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

   175

   176

    def AddTree(self, context, *args):

   177

        self.TreeStack.append([])

   178

        self.Dimensions = []

   179

   180

    def AddVarToTree(self, context, *args):

   181

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

   182

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

   183

   184

    def AddVariable(self, context, *args):

   185

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

   186

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

   187

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

   188

   189

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

   190

#            Helpers object for generating pou variable instance list

   191

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

   192

   193

def class_extraction(value):

   194

    class_type = {

   195

        "configuration": ITEM_CONFIGURATION,

   196

        "resource": ITEM_RESOURCE,

   197

        "action": ITEM_ACTION,

   198

        "transition": ITEM_TRANSITION,

   199

        "program": ITEM_PROGRAM}.get(value)

   200

    if class_type is not None:

   201

        return class_type

   202

   203

    pou_type = POU_TYPES.get(value)

   204

    if pou_type is not None:

   205

        return pou_type

   206

   207

    var_type = VAR_CLASS_INFOS.get(value)

   208

    if var_type is not None:

   209

        return var_type[1]

   210

   211

    return None

   212

   213

class _VariablesTreeItemInfos(object):

   214

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

   215

    def __init__(self, *args):

   216

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

   217

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

   218

    def copy(self):

   219

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

   220

   221

class VariablesTreeInfosFactory:

   222

   223

    def __init__(self):

   224

        self.Root = None

   225

   226

    def GetRoot(self):

   227

        return self.Root

   228

   229

    def SetRoot(self, context, *args):

   230

        self.Root = _VariablesTreeItemInfos(

   231

            *([''] + _translate_args(

   232

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

   233

                args) + [[]]))

   234

   235

    def AddVariable(self, context, *args):

   236

        if self.Root is not None:

   237

            self.Root.variables.append(_VariablesTreeItemInfos(

   238

                *(_translate_args(

   239

                    [_StringValue, class_extraction, _StringValue] + 

   240

                    [_BoolValue] * 2, args) + [[]])))

   241

   242

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

   243

#            Helpers object for generating instances path list

   244

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

   245

   246

class InstancesPathFactory:

   247

   248

    def __init__(self, instances):

   249

        self.Instances = instances

   250

   251

    def AddInstance(self, context, *args):

   252

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

   253

   254

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

   255

#            Helpers object for generating instance tagname

   256

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

   257

   258

class InstanceTagName:

   259

   260

    def __init__(self, controller):

   261

        self.Controller = controller

   262

        self.TagName = None

   263

   264

    def GetTagName(self):

   265

        return self.TagName

   266

   267

    def ConfigTagName(self, context, *args):

   268

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

   269

   270

    def ResourceTagName(self, context, *args):

   271

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

   272

   273

    def PouTagName(self, context, *args):

   274

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

   275

   276

    def ActionTagName(self, context, *args):

   277

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

   278

   279

    def TransitionTagName(self, context, *args):

   280

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

   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

    [_StringValue, int])

   295

_VariableSpecificValues = (

   296

    namedtuple("VariableSpecificValues", 

   297

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

   298

    [_StringValue, _StringValue, int])

   299

_ConnectionSpecificValues = (

   300

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

   301

    [_StringValue])

   302

   303

_PowerRailSpecificValues = (

   304

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

   305

    [int])

   306

   307

_LDElementSpecificValues = (

   308

    namedtuple("LDElementSpecificValues", 

   309

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

   310

    [_StringValue, _BoolValue, _StringValue, _StringValue, int])

   311

   312

_DivergenceSpecificValues = (

   313

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

   314

    [int])

   315

   316

_SpecificValuesTuples = {

   317

    "comment": (

   318

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

   319

        [_StringValue]),

   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

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

   332

    "transition": (

   333

        namedtuple("TransitionSpecificValues", 

   334

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

   335

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

   336

    "selectionDivergence": _DivergenceSpecificValues,

   337

    "selectionConvergence": _DivergenceSpecificValues,

   338

    "simultaneousDivergence": _DivergenceSpecificValues,

   339

    "simultaneousConvergence": _DivergenceSpecificValues,

   340

    "jump": (

   341

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

   342

        [_StringValue]),

   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([_StringValue, int] + [float] * 4, 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

            [_StringValue] * 2 + [_BoolValue, _StringValue] + [float] * 2, 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, _StringValue], args) + [[]]))

   415

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

   416

   417

    def AddLinkPoint(self, context, *args):

   418

        self.CurrentLink.points.append(_Point(

   419

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

   420

   421

    def AddAction(self, context, *args):

   422

        if len(self.SpecificValues) == 0:

   423

            self.SpecificValues.append([[]])

   424

        translated_args = _translate_args([_StringValue] * 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