1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

# This program is free software; you can redistribute it and/or

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

# of the License, or (at your option) any later version.

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

# You should have received a copy of the GNU General Public License

    23

# along with this program; if not, write to the Free Software

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

from xml.dom import minidom

    27

from types import StringType, UnicodeType, TupleType

    28

from lxml import etree

    29

from copy import deepcopy

    30

import os

    31

import sys

    32

import re

    33

import datetime

    34

import util.paths as paths

    35

from time import localtime

    36

from collections import OrderedDict, namedtuple

    37

    38

from plcopen import *

    39

from graphics.GraphicCommons import *

    40

from PLCGenerator import *

    41

    42

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

    43

    44

ITEMS_EDITABLE = [ITEM_PROJECT,

    45

                  ITEM_POU,

    46

                  ITEM_VARIABLE,

    47

                  ITEM_TRANSITION,

    48

                  ITEM_ACTION,

    49

                  ITEM_CONFIGURATION,

    50

                  ITEM_RESOURCE,

    51

                  ITEM_DATATYPE

    52

                 ] = range(8)

    53

    54

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    55

                    ITEM_FUNCTION,

    56

                    ITEM_FUNCTIONBLOCK,

    57

                    ITEM_PROGRAM,

    58

                    ITEM_TRANSITIONS,

    59

                    ITEM_ACTIONS,

    60

                    ITEM_CONFIGURATIONS,

    61

                    ITEM_RESOURCES,

    62

                    ITEM_PROPERTIES

    63

                   ] = range(8, 17)

    64

    65

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    66

                  ITEM_VAR_GLOBAL,

    67

                  ITEM_VAR_EXTERNAL,

    68

                  ITEM_VAR_TEMP,

    69

                  ITEM_VAR_INPUT,

    70

                  ITEM_VAR_OUTPUT,

    71

                  ITEM_VAR_INOUT

    72

                 ] = range(17, 24)

    73

    74

VAR_CLASS_INFOS = {

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

    83

POU_TYPES = {"program": ITEM_PROGRAM,

    84

             "functionBlock": ITEM_FUNCTIONBLOCK,

    85

             "function": ITEM_FUNCTION,

    86

            }

    87

    88

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    89

                   LOCATION_MODULE,

    90

                   LOCATION_GROUP,

    91

                   LOCATION_VAR_INPUT,

    92

                   LOCATION_VAR_OUTPUT,

    93

                   LOCATION_VAR_MEMORY] = range(6)

    94

    95

ScriptDirectory = paths.AbsDir(__file__)

    96

    98

def GetUneditableNames():

    99

    _ = lambda x:x

   100

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

   101

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

   102

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

   103

UNEDITABLE_NAMES = GetUneditableNames()

   104

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   105

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   106

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   107

   108

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

   109

#                 Helper object for loading library in xslt stylesheets

   110

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

   111

   113

class LibraryResolver(etree.Resolver):

   114

   115

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

   116

        self.Controller = controller

   117

        self.Debug = debug

   118

   119

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

   120

        lib_name = os.path.basename(url)

   121

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

   122

            lib_el = etree.Element(lib_name)

   123

            if lib_name == "project":

   124

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

   125

            elif lib_name == "stdlib":

   126

                for lib in StdBlckLibs.values():

   127

                    lib_el.append(deepcopy(lib))

   128

            else:

   129

                for ctn in self.Controller.ConfNodeTypes:

   130

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

   131

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

   132

   133

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

   134

#           Helpers functions for translating list of arguments

   135

#                       from xslt to valid arguments

   136

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

   137

   138

_StringValue = lambda x: x

   139

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

   140

   142

def _translate_args(translations, args):

   143

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

   144

            for translate, arg in

   145

            zip(translations, args)]

   146

   147

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

   148

#                 Helpers object for generating pou var list

   149

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

   150

   152

class _VariableInfos(object):

   153

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

   154

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

   155

    def __init__(self, *args):

   156

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

   157

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

   158

    def copy(self):

   159

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

   160

   162

class VariablesInfosFactory:

   163

   164

    def __init__(self, variables):

   165

        self.Variables = variables

   166

        self.TreeStack = []

   167

        self.Type = None

   168

        self.Dimensions = None

   169

   170

    def SetType(self, context, *args):

   171

        self.Type = args[0][0]

   172

   173

    def GetType(self):

   174

        if len(self.Dimensions) > 0:

   175

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

   176

        return self.Type

   177

   178

    def GetTree(self):

   179

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

   180

   181

    def AddDimension(self, context, *args):

   182

        self.Dimensions.append(tuple(

   183

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

   184

   185

    def AddTree(self, context, *args):

   186

        self.TreeStack.append([])

   187

        self.Dimensions = []

   188

   189

    def AddVarToTree(self, context, *args):

   190

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

   191

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

   192

   193

    def AddVariable(self, context, *args):

   194

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

   195

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

   196

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

   197

   198

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

   199

#            Helpers object for generating pou variable instance list

   200

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

   201

   203

def class_extraction(value):

   204

    class_type = {

   205

        "configuration": ITEM_CONFIGURATION,

   206

        "resource": ITEM_RESOURCE,

   207

        "action": ITEM_ACTION,

   208

        "transition": ITEM_TRANSITION,

   209

        "program": ITEM_PROGRAM}.get(value)

   210

    if class_type is not None:

   211

        return class_type

   212

   213

    pou_type = POU_TYPES.get(value)

   214

    if pou_type is not None:

   215

        return pou_type

   216

   217

    var_type = VAR_CLASS_INFOS.get(value)

   218

    if var_type is not None:

   219

        return var_type[1]

   220

   221

    return None

   222

   224

class _VariablesTreeItemInfos(object):

   225

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

   226

    def __init__(self, *args):

   227

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

   228

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

   229

    def copy(self):

   230

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

   231

   233

class VariablesTreeInfosFactory:

   234

   235

    def __init__(self):

   236

        self.Root = None

   237

   238

    def GetRoot(self):

   239

        return self.Root

   240

   241

    def SetRoot(self, context, *args):

   242

        self.Root = _VariablesTreeItemInfos(

   243

            *([''] + _translate_args(

   244

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

   245

                args) + [[]]))

   246

   247

    def AddVariable(self, context, *args):

   248

        if self.Root is not None:

   249

            self.Root.variables.append(_VariablesTreeItemInfos(

   250

                *(_translate_args(

   251

                    [_StringValue, class_extraction, _StringValue] +

   252

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

   253

   254

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

   255

#            Helpers object for generating instances path list

   256

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

   257

   259

class InstancesPathFactory:

   260

   261

    def __init__(self, instances):

   262

        self.Instances = instances

   263

   264

    def AddInstance(self, context, *args):

   265

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

   266

   267

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

   268

#            Helpers object for generating instance tagname

   269

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

   270

   272

class InstanceTagName:

   273

   274

    def __init__(self, controller):

   275

        self.Controller = controller

   276

        self.TagName = None

   277

   278

    def GetTagName(self):

   279

        return self.TagName

   280

   281

    def ConfigTagName(self, context, *args):

   282

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

   283

   284

    def ResourceTagName(self, context, *args):

   285

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

   286

   287

    def PouTagName(self, context, *args):

   288

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

   289

   290

    def ActionTagName(self, context, *args):

   291

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

   292

   293

    def TransitionTagName(self, context, *args):

   294

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

   295

   296

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

   297

#           Helpers object for generating pou block instances list

   298

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

   299

   300

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

   301

   302

_BlockInstanceInfos = namedtuple("BlockInstanceInfos",

   303

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

   304

   305

_BlockSpecificValues = (

   306

    namedtuple("BlockSpecificValues",

   307

               ["name", "execution_order"]),

   308

    [_StringValue, int])

   309

_VariableSpecificValues = (

   310

    namedtuple("VariableSpecificValues",

   311

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

   312

    [_StringValue, _StringValue, int])

   313

_ConnectionSpecificValues = (

   314

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

   315

    [_StringValue])

   316

   317

_PowerRailSpecificValues = (

   318

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

   319

    [int])

   320

   321

_LDElementSpecificValues = (

   322

    namedtuple("LDElementSpecificValues",

   323

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

   324

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

   325

   326

_DivergenceSpecificValues = (

   327

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

   328

    [int])

   329

   330

_SpecificValuesTuples = {

   331

    "comment": (

   332

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

   333

        [_StringValue]),

   334

    "input": _VariableSpecificValues,

   335

    "output": _VariableSpecificValues,

   336

    "inout": _VariableSpecificValues,

   337

    "connector": _ConnectionSpecificValues,

   338

    "continuation": _ConnectionSpecificValues,

   339

    "leftPowerRail": _PowerRailSpecificValues,

   340

    "rightPowerRail": _PowerRailSpecificValues,

   341

    "contact": _LDElementSpecificValues,

   342

    "coil": _LDElementSpecificValues,

   343

    "step": (

   344

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

   345

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

   346

    "transition": (

   347

        namedtuple("TransitionSpecificValues",

   348

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

   349

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

   350

    "selectionDivergence": _DivergenceSpecificValues,

   351

    "selectionConvergence": _DivergenceSpecificValues,

   352

    "simultaneousDivergence": _DivergenceSpecificValues,

   353

    "simultaneousConvergence": _DivergenceSpecificValues,

   354

    "jump": (

   355

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

   356

        [_StringValue]),

   357

    "actionBlock": (

   358

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

   359

        [lambda x: x]),

   360

}

   361

   362

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   363

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

   364

   365

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   366

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

   367

   369

class _ActionInfos(object):

   370

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

   371

    def __init__(self, *args):

   372

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

   373

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

   374

    def copy(self):

   375

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

   376

   378

class BlockInstanceFactory:

   379

   380

    def __init__(self, block_instances):

   381

        self.BlockInstances = block_instances

   382

        self.CurrentInstance = None

   383

        self.SpecificValues = None

   384

        self.CurrentConnection = None

   385

        self.CurrentLink = None

   386

   387

    def SetSpecificValues(self, context, *args):

   388

        self.SpecificValues = list(args)

   389

        self.CurrentInstance = None

   390

        self.CurrentConnection = None

   391

        self.CurrentLink = None

   392

   393

    def AddBlockInstance(self, context, *args):

   394

        specific_values_tuple, specific_values_translation = \

   395

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

   396

   397

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

   398

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

   399

            self.SpecificValues.append([None])

   400

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

   401

            self.SpecificValues.append([[]])

   402

        specific_values = specific_values_tuple(*_translate_args(

   403

            specific_values_translation, self.SpecificValues))

   404

        self.SpecificValues = None

   405

   406

        self.CurrentInstance = _BlockInstanceInfos(

   407

            *(_translate_args([_StringValue, int] + [float] * 4, args) +

   408

              [specific_values, [], []]))

   409

   410

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

   411

   412

    def AddInstanceConnection(self, context, *args):

   413

        connection_args = _translate_args(

   414

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

   415

   416

        self.CurrentConnection = _InstanceConnectionInfos(

   417

            *(connection_args[1:4] + [

   418

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

   419

   420

        if self.CurrentInstance is not None:

   421

            if connection_args[0] == "input":

   422

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

   423

            else:

   424

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

   425

        else:

   426

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

   427

   428

    def AddConnectionLink(self, context, *args):

   429

        self.CurrentLink = _ConnectionLinkInfos(

   430

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

   431

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

   432

   433

    def AddLinkPoint(self, context, *args):

   434

        self.CurrentLink.points.append(_Point(

   435

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

   436

   437

    def AddAction(self, context, *args):

   438

        if len(self.SpecificValues) == 0:

   439

            self.SpecificValues.append([[]])

   440

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

   441

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

   442

   443

pou_block_instances_xslt = etree.parse(

   444

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

   445

   446

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

   447

#                         Undo Buffer for PLCOpenEditor

   448

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

   449

   450

# Length of the buffer

   451

UNDO_BUFFER_LENGTH = 20

   452

   454

class UndoBuffer:

   459

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

   463

        self.Buffer = []

   464

        self.CurrentIndex = -1

   465

        self.MinIndex = -1

   466

        self.MaxIndex = -1

   467

        # if current state is defined

   468

        if currentstate:

   469

            self.CurrentIndex = 0

   470

            self.MinIndex = 0

   471

            self.MaxIndex = 0

   472

        # Initialising buffer with currentstate at the first place

   473

        for i in xrange(UNDO_BUFFER_LENGTH):

   474

            if i == 0:

   475

                self.Buffer.append(currentstate)

   476

            else:

   477

                self.Buffer.append(None)

   478

        # Initialising index of state saved

   479

        if issaved:

   480

            self.LastSave = 0

   481

        else:

   482

            self.LastSave = -1

   483

   485

    def Buffering(self, currentstate):

   489

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

   490

        self.Buffer[self.CurrentIndex] = currentstate