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.types_enums import *

    42

from plcopen.XSLTModelQuery import  _StringValue, _BoolValue, _translate_args

    43

from plcopen.InstancesPathCollector import InstancesPathCollector

    44

from plcopen.POUVariablesCollector import POUVariablesCollector

    45

from graphics.GraphicCommons import *

    46

from PLCGenerator import *

    47

    48

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

    49

    50

ScriptDirectory = paths.AbsDir(__file__)

    51

    52

class LibraryResolver(etree.Resolver):

    53

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

    54

    55

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

    56

        self.Controller = controller

    57

        self.Debug = debug

    58

    59

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

    60

        # TODO stop deepcopy

    61

        lib_name = os.path.basename(url)

    62

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

    63

            lib_el = etree.Element(lib_name)

    64

            if lib_name == "project":

    65

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

    66

            elif lib_name == "stdlib":

    67

                for lib in StdBlckLibs.values():

    68

                    lib_el.append(deepcopy(lib))

    69

            else:

    70

                for ctn in self.Controller.ConfNodeTypes:

    71

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

    72

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

    73

    74

    75

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

    76

#                 Helpers object for generating pou var list

    77

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

    78

    79

    80

class _VariableInfos(object):

    81

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

    82

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

    83

    84

    def __init__(self, *args):

    85

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

    86

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

    87

    88

    def copy(self):

    89

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

    90

    91

    92

class VariablesInfosFactory(object):

    93

    94

    def __init__(self, variables):

    95

        self.Variables = variables

    96

        self.TreeStack = []

    97

        self.Type = None

    98

        self.Dimensions = None

    99

   100

    def SetType(self, context, *args):

   101

        self.Type = args[0][0]

   102

   103

    def GetType(self):

   104

        if len(self.Dimensions) > 0:

   105

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

   106

        return self.Type

   107

   108

    def GetTree(self):

   109

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

   110

   111

    def AddDimension(self, context, *args):

   112

        self.Dimensions.append(tuple(

   113

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

   114

   115

    def AddTree(self, context, *args):

   116

        self.TreeStack.append([])

   117

        self.Dimensions = []

   118

   119

    def AddVarToTree(self, context, *args):

   120

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

   121

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

   122

   123

    def AddVariable(self, context, *args):

   124

        self.Variables.append(_VariableInfos(*(

   125

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

   126

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

   127

   128

class InstanceTagName(object):

   129

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

   130

   131

    def __init__(self, controller):

   132

        self.Controller = controller

   133

        self.TagName = None

   134

   135

    def GetTagName(self):

   136

        return self.TagName

   137

   138

    def ConfigTagName(self, context, *args):

   139

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

   140

   141

    def ResourceTagName(self, context, *args):

   142

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

   143

   144

    def PouTagName(self, context, *args):

   145

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

   146

   147

    def ActionTagName(self, context, *args):

   148

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

   149

   150

    def TransitionTagName(self, context, *args):

   151

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

   152

   153

   154

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

   155

#           Helpers object for generating pou block instances list

   156

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

   157

   158

   159

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

   160

   161

_BlockInstanceInfos = namedtuple(

   162

    "BlockInstanceInfos",

   163

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

   164

   165

_BlockSpecificValues = (

   166

    namedtuple("BlockSpecificValues",

   167

               ["name", "execution_order"]),

   168

    [_StringValue, int])

   169

_VariableSpecificValues = (

   170

    namedtuple("VariableSpecificValues",

   171

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

   172

    [_StringValue, _StringValue, int])

   173

_ConnectionSpecificValues = (

   174

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

   175

    [_StringValue])

   176

   177

_PowerRailSpecificValues = (

   178

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

   179

    [int])

   180

   181

_LDElementSpecificValues = (

   182

    namedtuple("LDElementSpecificValues",

   183

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

   184

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

   185

   186

_DivergenceSpecificValues = (

   187

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

   188

    [int])

   189

   190

_SpecificValuesTuples = {

   191

    "comment": (

   192

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

   193

        [_StringValue]),

   194

    "input": _VariableSpecificValues,

   195

    "output": _VariableSpecificValues,

   196

    "inout": _VariableSpecificValues,

   197

    "connector": _ConnectionSpecificValues,

   198

    "continuation": _ConnectionSpecificValues,

   199

    "leftPowerRail": _PowerRailSpecificValues,

   200

    "rightPowerRail": _PowerRailSpecificValues,

   201

    "contact": _LDElementSpecificValues,

   202

    "coil": _LDElementSpecificValues,

   203

    "step": (

   204

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

   205

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

   206

    "transition": (

   207

        namedtuple("TransitionSpecificValues",

   208

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

   209

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

   210

    "selectionDivergence": _DivergenceSpecificValues,

   211

    "selectionConvergence": _DivergenceSpecificValues,

   212

    "simultaneousDivergence": _DivergenceSpecificValues,

   213

    "simultaneousConvergence": _DivergenceSpecificValues,

   214

    "jump": (

   215

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

   216

        [_StringValue]),

   217

    "actionBlock": (

   218

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

   219

        [lambda x: x]),

   220

}

   221

   222

_InstanceConnectionInfos = namedtuple(

   223

    "InstanceConnectionInfos",

   224

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

   225

   226

_ConnectionLinkInfos = namedtuple(

   227

    "ConnectionLinkInfos",

   228

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

   229

   230

   231

class _ActionInfos(object):

   232

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

   233

   234

    def __init__(self, *args):

   235

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

   236

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

   237

   238

    def copy(self):

   239

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

   240

   241

   242

class BlockInstanceFactory(object):

   243

   244

    def __init__(self, block_instances):

   245

        self.BlockInstances = block_instances

   246

        self.CurrentInstance = None

   247

        self.SpecificValues = None

   248

        self.CurrentConnection = None

   249

        self.CurrentLink = None

   250

   251

    def SetSpecificValues(self, context, *args):

   252

        self.SpecificValues = list(args)

   253

        self.CurrentInstance = None

   254

        self.CurrentConnection = None

   255

        self.CurrentLink = None

   256

   257

    def AddBlockInstance(self, context, *args):

   258

        specific_values_tuple, specific_values_translation = \

   259

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

   260

   261

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

   262

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

   263

            self.SpecificValues.append([None])

   264

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

   265

            self.SpecificValues.append([[]])

   266

        specific_values = specific_values_tuple(*_translate_args(

   267

            specific_values_translation, self.SpecificValues))

   268

        self.SpecificValues = None

   269

   270

        self.CurrentInstance = _BlockInstanceInfos(

   271

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

   272

              [specific_values, [], []]))

   273

   274

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

   275

   276

    def AddInstanceConnection(self, context, *args):

   277

        connection_args = _translate_args(

   278

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

   279

   280

        self.CurrentConnection = _InstanceConnectionInfos(

   281

            *(connection_args[1:4] + [

   282

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

   283

   284

        if self.CurrentInstance is not None:

   285

            if connection_args[0] == "input":

   286

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

   287

            else:

   288

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

   289

        else:

   290

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

   291

   292

    def AddConnectionLink(self, context, *args):

   293

        self.CurrentLink = _ConnectionLinkInfos(

   294

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

   295

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

   296

   297

    def AddLinkPoint(self, context, *args):

   298

        self.CurrentLink.points.append(_Point(

   299

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

   300

   301

    def AddAction(self, context, *args):

   302

        if len(self.SpecificValues) == 0:

   303

            self.SpecificValues.append([[]])

   304

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

   305

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

   306

   307

   308

pou_block_instances_xslt = etree.parse(

   309

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

   310

   311

   312

# Length of the buffer

   313

UNDO_BUFFER_LENGTH = 20

   314

   315

   316

class UndoBuffer(object):

   317

    """

   318

    Undo Buffer for PLCOpenEditor

   319

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

   320

    """

   321

   322

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

   323

        """

   324

        Constructor initialising buffer

   325

        """

   326

        self.Buffer = []

   327

        self.CurrentIndex = -1

   328

        self.MinIndex = -1

   329

        self.MaxIndex = -1

   330

        # if current state is defined

   331

        if currentstate:

   332

            self.CurrentIndex = 0

   333

            self.MinIndex = 0

   334

            self.MaxIndex = 0

   335

        # Initialising buffer with currentstate at the first place

   336

        for i in xrange(UNDO_BUFFER_LENGTH):

   337

            if i == 0:

   338

                self.Buffer.append(currentstate)

   339

            else:

   340

                self.Buffer.append(None)

   341

        # Initialising index of state saved

   342

        if issaved:

   343

            self.LastSave = 0

   344

        else:

   345

            self.LastSave = -1

   346

   347

    def Buffering(self, currentstate):

   348

        """

   349

        Add a new state in buffer

   350

        """

   351

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

   352

        self.Buffer[self.CurrentIndex] = currentstate

   353

        # Actualising buffer limits

   354

        self.MaxIndex = self.CurrentIndex

   355

        if self.MinIndex == self.CurrentIndex:

   356

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

   357

            if self.LastSave == self.MinIndex:

   358

                self.LastSave = -1

   359

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

   360

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

   361

   362

    def Current(self):

   363

        """

   364

        Return current state of buffer

   365

        """

   366

        return self.Buffer[self.CurrentIndex]

   367

   368

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

   369

    def Previous(self):

   370

        if self.CurrentIndex != self.MinIndex:

   371

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

   372

            return self.Buffer[self.CurrentIndex]

   373

        return None

   374

   375

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

   376

    def Next(self):

   377

        if self.CurrentIndex != self.MaxIndex:

   378

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

   379

            return self.Buffer[self.CurrentIndex]

   380

        return None

   381

   382

    # Return True if current state is the first in buffer

   383

    def IsFirst(self):

   384

        return self.CurrentIndex == self.MinIndex

   385

   386

    # Return True if current state is the last in buffer

   387

    def IsLast(self):

   388

        return self.CurrentIndex == self.MaxIndex

   389

   390

    # Note that current state is saved

   391

    def CurrentSaved(self):

   392

        self.LastSave = self.CurrentIndex

   393

   394

    # Return True if current state is saved

   395

    def IsCurrentSaved(self):

   396

        return self.LastSave == self.CurrentIndex

   397

   398

   399

class PLCControler(object):

   400

    """

   401

    Controler for PLCOpenEditor

   402

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

   403

    """

   404

   405

    # Create a new PLCControler

   406

    def __init__(self):

   407

        self.LastNewIndex = 0

   408

        self.Reset()

   409

        self.InstancesPathCollector = InstancesPathCollector(self)

   410

        self.POUVariablesCollector = POUVariablesCollector(self)

   411

   412

    # Reset PLCControler internal variables

   413

    def Reset(self):

   414

        self.Project = None

   415

        self.ProjectBufferEnabled = True

   416

        self.ProjectBuffer = None

   417

        self.ProjectSaved = True

   418

        self.Buffering = False

   419

        self.FilePath = ""

   420

        self.FileName = ""

   421

        self.ProgramChunks = []

   422

        self.ProgramOffset = 0

   423

        self.NextCompiledProject = None

   424

        self.CurrentCompiledProject = None

   425

        self.ConfNodeTypes = []

   426

        self.TotalTypesDict = StdBlckDct.copy()

   427

        self.TotalTypes = StdBlckLst[:]

   428

        self.ProgramFilePath = ""

   429

   430

    def GetQualifierTypes(self):

   431

        return QualifierList

   432

   433

    def GetProject(self, debug=False):

   434

        if debug and self.CurrentCompiledProject is not None:

   435

            return self.CurrentCompiledProject

   436

        else:

   437

            return self.Project

   438

   439

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

   440

    #                         Project management functions

   441

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

   442

   443

    # Return if a project is opened

   444

    def HasOpenedProject(self):

   445

        return self.Project is not None

   446

   447

    # Create a new project by replacing the current one

   448

    def CreateNewProject(self, properties):

   449

        # Create the project

   450

        self.Project = PLCOpenParser.CreateRoot()

   451

        properties["creationDateTime"] = datetime.datetime(*localtime()[:6])

   452

        self.Project.setfileHeader(properties)

   453

        self.Project.setcontentHeader(properties)

   454

        self.SetFilePath("")

   455

   456

        # Initialize the project buffer

   457

        self.CreateProjectBuffer(False)

   458

        self.ProgramChunks = []

   459

        self.ProgramOffset = 0

   460

        self.NextCompiledProject = self.Copy(self.Project)

   461

        self.CurrentCompiledProject = None

   462

        self.Buffering = False

   463

   464

    # Return project data type names

   465

    def GetProjectDataTypeNames(self, debug=False):

   466

        project = self.GetProject(debug)

   467

        if project is not None:

   468

            return [datatype.getname() for datatype in project.getdataTypes()]

   469

        return []

   470

   471

    # Return project pou names

   472

    def GetProjectPouNames(self, debug=False):

   473

        project = self.GetProject(debug)

   474

        if project is not None:

   475

            return [pou.getname() for pou in project.getpous()]

   476

        return []

   477

   478

    # Return project pou names

   479

    def GetProjectConfigNames(self, debug=False):

   480

        project = self.GetProject(debug)

   481

        if project is not None:

   482

            return [config.getname() for config in project.getconfigurations()]

   483

        return []

   484

   485

    # Return project pou variable names

   486

    def GetProjectPouVariableNames(self, pou_name=None, debug=False):

   487

        variables = []

   488

        project = self.GetProject(debug)

   489

        if project is not None:

   490

            for pou in project.getpous():

   491

                if pou_name is None or pou_name == pou.getname():