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

    27

from __future__ import absolute_import

    28

from types import TupleType

    29

from copy import deepcopy

    30

import os

    31

import re

    32

import datetime

    33

from time import localtime

    34

from collections import OrderedDict, namedtuple

    35

    36

from lxml import etree

    37

    38

import util.paths as paths

    39

from util.TranslationCatalogs import NoTranslate

    40

from plcopen import *

    41

from plcopen.InstancesPathCollector import InstancesPathCollector

    43

from graphics.GraphicCommons import *

    44

from PLCGenerator import *

    45

    46

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

    47

    48

ITEMS_EDITABLE = [

    49

    ITEM_PROJECT,

    50

    ITEM_POU,

    51

    ITEM_VARIABLE,

    52

    ITEM_TRANSITION,

    53

    ITEM_ACTION,

    54

    ITEM_CONFIGURATION,

    55

    ITEM_RESOURCE,

    56

    ITEM_DATATYPE

    57

] = range(8)

    58

    59

ITEMS_UNEDITABLE = [

    60

    ITEM_DATATYPES,

    61

    ITEM_FUNCTION,

    62

    ITEM_FUNCTIONBLOCK,

    63

    ITEM_PROGRAM,

    64

    ITEM_TRANSITIONS,

    65

    ITEM_ACTIONS,

    66

    ITEM_CONFIGURATIONS,

    67

    ITEM_RESOURCES,

    68

    ITEM_PROPERTIES

    69

] = range(8, 17)

    70

    71

ITEMS_VARIABLE = [

    72

    ITEM_VAR_LOCAL,

    73

    ITEM_VAR_GLOBAL,

    74

    ITEM_VAR_EXTERNAL,

    75

    ITEM_VAR_TEMP,

    76

    ITEM_VAR_INPUT,

    77

    ITEM_VAR_OUTPUT,

    78

    ITEM_VAR_INOUT

    79

] = range(17, 24)

    80

    81

VAR_CLASS_INFOS = {

    82

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

    83

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

    84

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

    85

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

    86

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

    87

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

    88

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

    89

    90

POU_TYPES = {

    91

    "program": ITEM_PROGRAM,

    92

    "functionBlock": ITEM_FUNCTIONBLOCK,

    93

    "function": ITEM_FUNCTION,

    94

}

    95

    96

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    97

                   LOCATION_MODULE,

    98

                   LOCATION_GROUP,

    99

                   LOCATION_VAR_INPUT,

   100

                   LOCATION_VAR_OUTPUT,

   101

                   LOCATION_VAR_MEMORY] = range(6)

   102

   103

ScriptDirectory = paths.AbsDir(__file__)

   104

   105

   106

def GetUneditableNames():

   107

    _ = NoTranslate

   108

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

   109

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

   110

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

   111

   112

   113

UNEDITABLE_NAMES = GetUneditableNames()

   114

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   115

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   116

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   117

   118

   119

class LibraryResolver(etree.Resolver):

   120

    """Helper object for loading library in xslt stylesheets"""

   121

   122

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

   123

        self.Controller = controller

   124

        self.Debug = debug

   125

   126

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

   127

        # TODO stop deepcopy

   128

        lib_name = os.path.basename(url)

   129

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

   130

            lib_el = etree.Element(lib_name)

   131

            if lib_name == "project":

   132

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

   133

            elif lib_name == "stdlib":

   134

                for lib in StdBlckLibs.values():

   135

                    lib_el.append(deepcopy(lib))

   136

            else:

   137

                for ctn in self.Controller.ConfNodeTypes:

   138

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

   139

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

   140

   141

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

   142

#           Helpers functions for translating list of arguments

   143

#                       from xslt to valid arguments

   144

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

   145

   146

   147

def _StringValue(x):

   148

    return x

   149

   150

   151

def _BoolValue(x):

   152

    return x in ["true", "0"]

   153

   154

   155

def _translate_args(translations, args):

   156

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

   157

            for translate, arg in

   158

            zip(translations, args)]

   159

   160

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

   161

#                 Helpers object for generating pou var list

   162

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

   163

   164

   165

class _VariableInfos(object):

   166

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

   167

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

   168

   169

    def __init__(self, *args):

   170

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

   171

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

   172

   173

    def copy(self):

   174

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

   175

   176

   177

class VariablesInfosFactory(object):

   178

   179

    def __init__(self, variables):

   180

        self.Variables = variables

   181

        self.TreeStack = []

   182

        self.Type = None

   183

        self.Dimensions = None

   184

   185

    def SetType(self, context, *args):

   186

        self.Type = args[0][0]

   187

   188

    def GetType(self):

   189

        if len(self.Dimensions) > 0:

   190

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

   191

        return self.Type

   192

   193

    def GetTree(self):

   194

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

   195

   196

    def AddDimension(self, context, *args):

   197

        self.Dimensions.append(tuple(

   198

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

   199

   200

    def AddTree(self, context, *args):

   201

        self.TreeStack.append([])

   202

        self.Dimensions = []

   203

   204

    def AddVarToTree(self, context, *args):

   205

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

   206

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

   207

   208

    def AddVariable(self, context, *args):

   209

        self.Variables.append(_VariableInfos(*(

   210

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

   211

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

   212

   213

class InstanceTagName(object):

   214

    """Helpers object for generating instance tagname"""

   215

   216

    def __init__(self, controller):

   217

        self.Controller = controller

   218

        self.TagName = None

   219

   220

    def GetTagName(self):

   221

        return self.TagName

   222

   223

    def ConfigTagName(self, context, *args):

   224

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

   225

   226

    def ResourceTagName(self, context, *args):

   227

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

   228

   229

    def PouTagName(self, context, *args):

   230

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

   231

   232

    def ActionTagName(self, context, *args):

   233

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

   234

   235

    def TransitionTagName(self, context, *args):

   236

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

   237

   238

   239

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

   240

#           Helpers object for generating pou block instances list

   241

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

   242

   243

   244

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

   245

   246

_BlockInstanceInfos = namedtuple(

   247

    "BlockInstanceInfos",

   248

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

   249

   250

_BlockSpecificValues = (

   251

    namedtuple("BlockSpecificValues",

   252

               ["name", "execution_order"]),

   253

    [_StringValue, int])

   254

_VariableSpecificValues = (

   255

    namedtuple("VariableSpecificValues",

   256

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

   257

    [_StringValue, _StringValue, int])

   258

_ConnectionSpecificValues = (

   259

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

   260

    [_StringValue])

   261

   262

_PowerRailSpecificValues = (

   263

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

   264

    [int])

   265

   266

_LDElementSpecificValues = (

   267

    namedtuple("LDElementSpecificValues",

   268

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

   269

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

   270

   271

_DivergenceSpecificValues = (

   272

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

   273

    [int])

   274

   275

_SpecificValuesTuples = {

   276

    "comment": (

   277

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

   278

        [_StringValue]),

   279

    "input": _VariableSpecificValues,

   280

    "output": _VariableSpecificValues,

   281

    "inout": _VariableSpecificValues,

   282

    "connector": _ConnectionSpecificValues,

   283

    "continuation": _ConnectionSpecificValues,

   284

    "leftPowerRail": _PowerRailSpecificValues,

   285

    "rightPowerRail": _PowerRailSpecificValues,

   286

    "contact": _LDElementSpecificValues,

   287

    "coil": _LDElementSpecificValues,

   288

    "step": (

   289

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

   290

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

   291

    "transition": (

   292

        namedtuple("TransitionSpecificValues",

   293

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

   294

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

   295

    "selectionDivergence": _DivergenceSpecificValues,

   296

    "selectionConvergence": _DivergenceSpecificValues,

   297

    "simultaneousDivergence": _DivergenceSpecificValues,

   298

    "simultaneousConvergence": _DivergenceSpecificValues,

   299

    "jump": (

   300

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

   301

        [_StringValue]),

   302

    "actionBlock": (

   303

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

   304

        [lambda x: x]),

   305

}

   306

   307

_InstanceConnectionInfos = namedtuple(

   308

    "InstanceConnectionInfos",

   309

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

   310

   311

_ConnectionLinkInfos = namedtuple(

   312

    "ConnectionLinkInfos",

   313

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

   314

   315

   316

class _ActionInfos(object):

   317

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

   318

   319

    def __init__(self, *args):

   320

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

   321

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

   322

   323

    def copy(self):

   324

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

   325

   326

   327

class BlockInstanceFactory(object):

   328

   329

    def __init__(self, block_instances):

   330

        self.BlockInstances = block_instances

   331

        self.CurrentInstance = None

   332

        self.SpecificValues = None

   333

        self.CurrentConnection = None

   334

        self.CurrentLink = None

   335

   336

    def SetSpecificValues(self, context, *args):

   337

        self.SpecificValues = list(args)

   338

        self.CurrentInstance = None

   339

        self.CurrentConnection = None

   340

        self.CurrentLink = None

   341

   342

    def AddBlockInstance(self, context, *args):

   343

        specific_values_tuple, specific_values_translation = \

   344

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

   345

   346

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

   347

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

   348

            self.SpecificValues.append([None])

   349

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

   350

            self.SpecificValues.append([[]])

   351

        specific_values = specific_values_tuple(*_translate_args(

   352

            specific_values_translation, self.SpecificValues))

   353

        self.SpecificValues = None

   354

   355

        self.CurrentInstance = _BlockInstanceInfos(

   356

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

   357

              [specific_values, [], []]))

   358

   359

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

   360

   361

    def AddInstanceConnection(self, context, *args):

   362

        connection_args = _translate_args(

   363

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

   364

   365

        self.CurrentConnection = _InstanceConnectionInfos(

   366

            *(connection_args[1:4] + [

   367

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

   368

   369

        if self.CurrentInstance is not None:

   370

            if connection_args[0] == "input":

   371

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

   372

            else:

   373

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

   374

        else:

   375

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

   376

   377

    def AddConnectionLink(self, context, *args):

   378

        self.CurrentLink = _ConnectionLinkInfos(

   379

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

   380

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

   381

   382

    def AddLinkPoint(self, context, *args):

   383

        self.CurrentLink.points.append(_Point(

   384

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

   385

   386

    def AddAction(self, context, *args):

   387

        if len(self.SpecificValues) == 0:

   388

            self.SpecificValues.append([[]])

   389

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

   390

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

   391

   392

   393

pou_block_instances_xslt = etree.parse(

   394

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

   395

   396

   397

# Length of the buffer

   398

UNDO_BUFFER_LENGTH = 20

   399

   400

   401

class UndoBuffer(object):

   402

    """

   403

    Undo Buffer for PLCOpenEditor

   404

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

   405

    """

   406

   407

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

   408

        """

   409

        Constructor initialising buffer

   410

        """

   411

        self.Buffer = []

   412

        self.CurrentIndex = -1

   413

        self.MinIndex = -1

   414

        self.MaxIndex = -1

   415

        # if current state is defined

   416

        if currentstate:

   417

            self.CurrentIndex = 0

   418

            self.MinIndex = 0

   419

            self.MaxIndex = 0

   420

        # Initialising buffer with currentstate at the first place

   421

        for i in xrange(UNDO_BUFFER_LENGTH):

   422

            if i == 0:

   423

                self.Buffer.append(currentstate)

   424

            else:

   425

                self.Buffer.append(None)

   426

        # Initialising index of state saved

   427

        if issaved:

   428

            self.LastSave = 0

   429

        else:

   430

            self.LastSave = -1

   431

   432

    def Buffering(self, currentstate):

   433

        """

   434

        Add a new state in buffer

   435

        """

   436

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

   437

        self.Buffer[self.CurrentIndex] = currentstate

   438

        # Actualising buffer limits

   439

        self.MaxIndex = self.CurrentIndex

   440

        if self.MinIndex == self.CurrentIndex:

   441

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

   442

            if self.LastSave == self.MinIndex:

   443

                self.LastSave = -1

   444

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

   445

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

   446

   447

    def Current(self):

   448

        """

   449

        Return current state of buffer

   450

        """

   451

        return self.Buffer[self.CurrentIndex]

   452

   453

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

   454

    def Previous(self):

   455

        if self.CurrentIndex != self.MinIndex:

   456

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

   457

            return self.Buffer[self.CurrentIndex]

   458

        return None

   459

   460

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

   461

    def Next(self):

   462

        if self.CurrentIndex != self.MaxIndex:

   463

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

   464

            return self.Buffer[self.CurrentIndex]

   465

        return None

   466

   467

    # Return True if current state is the first in buffer

   468

    def IsFirst(self):

   469

        return self.CurrentIndex == self.MinIndex

   470

   471

    # Return True if current state is the last in buffer

   472

    def IsLast(self):

   473

        return self.CurrentIndex == self.MaxIndex

   474

   475

    # Note that current state is saved

   476

    def CurrentSaved(self):

   477

        self.LastSave = self.CurrentIndex

   478

   479

    # Return True if current state is saved

   480

    def IsCurrentSaved(self):

   481

        return self.LastSave == self.CurrentIndex

   482

   483

   484

class PLCControler(object):

   485

    """

   486

    Controler for PLCOpenEditor

   487

    Class which controls the operations made on the plcopen model and answers to view requests

   488

    """