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

    46

from graphics.GraphicCommons import *

    47

from PLCGenerator import *

    48

    49

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

    50

    51

ScriptDirectory = paths.AbsDir(__file__)

    52

    53

class LibraryResolver(etree.Resolver):

    54

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

    55

    56

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

    57

        self.Controller = controller

    58

        self.Debug = debug

    59

    60

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

    61

        # TODO stop deepcopy

    62

        lib_name = os.path.basename(url)

    63

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

    64

            lib_el = etree.Element(lib_name)

    65

            if lib_name == "project":

    66

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

    67

            elif lib_name == "stdlib":

    68

                for lib in StdBlckLibs.values():

    69

                    lib_el.append(deepcopy(lib))

    70

            else:

    71

                for ctn in self.Controller.ConfNodeTypes:

    72

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

    73

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

    74

    75

    76

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

    77

#                 Helpers object for generating pou var list

    78

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

    79

    80

    81

class _VariableInfos(object):

    82

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

    83

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

    84

    85

    def __init__(self, *args):

    86

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

    87

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

    88

    89

    def copy(self):

    90

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

    91

    92

    93

class VariablesInfosFactory(object):

    94

    95

    def __init__(self, variables):

    96

        self.Variables = variables

    97

        self.TreeStack = []

    98

        self.Type = None

    99

        self.Dimensions = None

   100

   101

    def SetType(self, context, *args):

   102

        self.Type = args[0][0]

   103

   104

    def GetType(self):

   105

        if len(self.Dimensions) > 0:

   106

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

   107

        return self.Type

   108

   109

    def GetTree(self):

   110

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

   111

   112

    def AddDimension(self, context, *args):

   113

        self.Dimensions.append(tuple(

   114

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

   115

   116

    def AddTree(self, context, *args):

   117

        self.TreeStack.append([])

   118

        self.Dimensions = []

   119

   120

    def AddVarToTree(self, context, *args):

   121

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

   122

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

   123

   124

    def AddVariable(self, context, *args):

   125

        self.Variables.append(_VariableInfos(*(

   126

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

   127

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

   128

   129

   130

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

   131

#           Helpers object for generating pou block instances list

   132

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

   133

   134

   135

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

   136

   137

_BlockInstanceInfos = namedtuple(

   138

    "BlockInstanceInfos",

   139

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

   140

   141

_BlockSpecificValues = (

   142

    namedtuple("BlockSpecificValues",

   143

               ["name", "execution_order"]),

   144

    [_StringValue, int])

   145

_VariableSpecificValues = (

   146

    namedtuple("VariableSpecificValues",

   147

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

   148

    [_StringValue, _StringValue, int])

   149

_ConnectionSpecificValues = (

   150

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

   151

    [_StringValue])

   152

   153

_PowerRailSpecificValues = (

   154

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

   155

    [int])

   156

   157

_LDElementSpecificValues = (

   158

    namedtuple("LDElementSpecificValues",

   159

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

   160

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

   161

   162

_DivergenceSpecificValues = (

   163

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

   164

    [int])

   165

   166

_SpecificValuesTuples = {

   167

    "comment": (

   168

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

   169

        [_StringValue]),

   170

    "input": _VariableSpecificValues,

   171

    "output": _VariableSpecificValues,

   172

    "inout": _VariableSpecificValues,

   173

    "connector": _ConnectionSpecificValues,

   174

    "continuation": _ConnectionSpecificValues,

   175

    "leftPowerRail": _PowerRailSpecificValues,

   176

    "rightPowerRail": _PowerRailSpecificValues,

   177

    "contact": _LDElementSpecificValues,

   178

    "coil": _LDElementSpecificValues,

   179

    "step": (

   180

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

   181

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

   182

    "transition": (

   183

        namedtuple("TransitionSpecificValues",

   184

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

   185

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

   186

    "selectionDivergence": _DivergenceSpecificValues,

   187

    "selectionConvergence": _DivergenceSpecificValues,

   188

    "simultaneousDivergence": _DivergenceSpecificValues,

   189

    "simultaneousConvergence": _DivergenceSpecificValues,

   190

    "jump": (

   191

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

   192

        [_StringValue]),

   193

    "actionBlock": (

   194

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

   195

        [lambda x: x]),

   196

}

   197

   198

_InstanceConnectionInfos = namedtuple(

   199

    "InstanceConnectionInfos",

   200

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

   201

   202

_ConnectionLinkInfos = namedtuple(

   203

    "ConnectionLinkInfos",

   204

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

   205

   206

   207

class _ActionInfos(object):

   208

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

   209

   210

    def __init__(self, *args):

   211

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

   212

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

   213

   214

    def copy(self):

   215

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

   216

   217

   218

class BlockInstanceFactory(object):

   219

   220

    def __init__(self, block_instances):

   221

        self.BlockInstances = block_instances

   222

        self.CurrentInstance = None

   223

        self.SpecificValues = None

   224

        self.CurrentConnection = None

   225

        self.CurrentLink = None

   226

   227

    def SetSpecificValues(self, context, *args):

   228

        self.SpecificValues = list(args)

   229

        self.CurrentInstance = None

   230

        self.CurrentConnection = None

   231

        self.CurrentLink = None

   232

   233

    def AddBlockInstance(self, context, *args):

   234

        specific_values_tuple, specific_values_translation = \

   235

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

   236

   237

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

   238

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

   239

            self.SpecificValues.append([None])

   240

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

   241

            self.SpecificValues.append([[]])

   242

        specific_values = specific_values_tuple(*_translate_args(

   243

            specific_values_translation, self.SpecificValues))

   244

        self.SpecificValues = None

   245

   246

        self.CurrentInstance = _BlockInstanceInfos(

   247

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

   248

              [specific_values, [], []]))

   249

   250

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

   251

   252

    def AddInstanceConnection(self, context, *args):

   253

        connection_args = _translate_args(

   254

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

   255

   256

        self.CurrentConnection = _InstanceConnectionInfos(

   257

            *(connection_args[1:4] + [

   258

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

   259

   260

        if self.CurrentInstance is not None:

   261

            if connection_args[0] == "input":

   262

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

   263

            else:

   264

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

   265

        else:

   266

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

   267

   268

    def AddConnectionLink(self, context, *args):

   269

        self.CurrentLink = _ConnectionLinkInfos(

   270

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

   271

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

   272

   273

    def AddLinkPoint(self, context, *args):

   274

        self.CurrentLink.points.append(_Point(

   275

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

   276

   277

    def AddAction(self, context, *args):

   278

        if len(self.SpecificValues) == 0:

   279

            self.SpecificValues.append([[]])

   280

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

   281

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

   282

   283

   284

pou_block_instances_xslt = etree.parse(

   285

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

   286

   287

   288

# Length of the buffer

   289

UNDO_BUFFER_LENGTH = 20

   290

   291

   292

class UndoBuffer(object):

   293

    """

   294

    Undo Buffer for PLCOpenEditor

   295

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

   296

    """

   297

   298

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

   299

        """

   300

        Constructor initialising buffer

   301

        """

   302

        self.Buffer = []

   303

        self.CurrentIndex = -1

   304

        self.MinIndex = -1

   305

        self.MaxIndex = -1

   306

        # if current state is defined

   307

        if currentstate:

   308

            self.CurrentIndex = 0

   309

            self.MinIndex = 0

   310

            self.MaxIndex = 0

   311

        # Initialising buffer with currentstate at the first place

   312

        for i in xrange(UNDO_BUFFER_LENGTH):

   313

            if i == 0:

   314

                self.Buffer.append(currentstate)

   315

            else:

   316

                self.Buffer.append(None)

   317

        # Initialising index of state saved

   318

        if issaved:

   319

            self.LastSave = 0

   320

        else:

   321

            self.LastSave = -1

   322

   323

    def Buffering(self, currentstate):

   324

        """

   325

        Add a new state in buffer

   326

        """

   327

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

   328

        self.Buffer[self.CurrentIndex] = currentstate

   329

        # Actualising buffer limits

   330

        self.MaxIndex = self.CurrentIndex

   331

        if self.MinIndex == self.CurrentIndex:

   332

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

   333

            if self.LastSave == self.MinIndex:

   334

                self.LastSave = -1

   335

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

   336

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

   337

   338

    def Current(self):

   339

        """

   340

        Return current state of buffer

   341

        """

   342

        return self.Buffer[self.CurrentIndex]

   343

   344

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

   345

    def Previous(self):

   346

        if self.CurrentIndex != self.MinIndex:

   347

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

   348

            return self.Buffer[self.CurrentIndex]

   349

        return None

   350

   351

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

   352

    def Next(self):

   353

        if self.CurrentIndex != self.MaxIndex:

   354

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

   355

            return self.Buffer[self.CurrentIndex]

   356

        return None

   357

   358

    # Return True if current state is the first in buffer

   359

    def IsFirst(self):

   360

        return self.CurrentIndex == self.MinIndex

   361

   362

    # Return True if current state is the last in buffer

   363

    def IsLast(self):

   364

        return self.CurrentIndex == self.MaxIndex

   365

   366

    # Note that current state is saved

   367

    def CurrentSaved(self):

   368

        self.LastSave = self.CurrentIndex

   369

   370

    # Return True if current state is saved

   371

    def IsCurrentSaved(self):

   372

        return self.LastSave == self.CurrentIndex

   373

   374

   375

class PLCControler(object):

   376

    """

   377

    Controler for PLCOpenEditor

   378

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

   379

    """

   380

   381

    # Create a new PLCControler

   382

    def __init__(self):

   383

        self.LastNewIndex = 0

   384

        self.Reset()

   385

        self.InstancesPathCollector = InstancesPathCollector(self)

   386

        self.POUVariablesCollector = POUVariablesCollector(self)

   388

   389

    # Reset PLCControler internal variables

   390

    def Reset(self):

   391

        self.Project = None

   392

        self.ProjectBufferEnabled = True

   393

        self.ProjectBuffer = None

   394

        self.ProjectSaved = True

   395

        self.Buffering = False

   396

        self.FilePath = ""

   397

        self.FileName = ""

   398

        self.ProgramChunks = []

   399

        self.ProgramOffset = 0

   400

        self.NextCompiledProject = None

   401

        self.CurrentCompiledProject = None

   402

        self.ConfNodeTypes = []

   403

        self.TotalTypesDict = StdBlckDct.copy()

   404

        self.TotalTypes = StdBlckLst[:]

   405

        self.ProgramFilePath = ""

   406

   407

    def GetQualifierTypes(self):

   408

        return QualifierList

   409

   410

    def GetProject(self, debug=False):

   411

        if debug and self.CurrentCompiledProject is not None:

   412

            return self.CurrentCompiledProject

   413

        else:

   414

            return self.Project

   415

   416

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

   417

    #                         Project management functions

   418

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

   419

   420

    # Return if a project is opened

   421

    def HasOpenedProject(self):

   422

        return self.Project is not None

   423

   424

    # Create a new project by replacing the current one

   425

    def CreateNewProject(self, properties):

   426

        # Create the project

   427

        self.Project = PLCOpenParser.CreateRoot()

   428

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

   429

        self.Project.setfileHeader(properties)

   430

        self.Project.setcontentHeader(properties)

   431

        self.SetFilePath("")

   432

   433

        # Initialize the project buffer

   434

        self.CreateProjectBuffer(False)

   435

        self.ProgramChunks = []

   436

        self.ProgramOffset = 0

   437

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

   438

        self.CurrentCompiledProject = None

   439

        self.Buffering = False

   440

   441

    # Return project data type names

   442

    def GetProjectDataTypeNames(self, debug=False):

   443

        project = self.GetProject(debug)

   444

        if project is not None:

   445

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

   446

        return []

   447

   448

    # Return project pou names

   449

    def GetProjectPouNames(self, debug=False):

   450

        project = self.GetProject(debug)

   451

        if project is not None:

   452

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

   453

        return []

   454

   455

    # Return project pou names

   456

    def GetProjectConfigNames(self, debug=False):

   457

        project = self.GetProject(debug)

   458

        if project is not None:

   459

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

   460

        return []

   461

   462

    # Return project pou variable names

   463

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

   464

        variables = []

   465

        project = self.GetProject(debug)

   466

        if project is not None:

   467

            for pou in project.getpous():

   468

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

   469

                    variables.extend([var.Name for var in self.GetPouInterfaceVars(pou, debug=debug)])

   470

                    for transition in pou.gettransitionList():

   471

                        variables.append(transition.getname())

   472

                    for action in pou.getactionList():

   473

                        variables.append(action.getname())

   474

        return variables

   475

   476

    # Return file path if project is an open file

   477

    def GetFilePath(self):

   478

        return self.FilePath

   479

   480

    # Return file path if project is an open file

   481

    def GetProgramFilePath(self):

   482

        return self.ProgramFilePath

   483

   484

    # Return file name and point out if file is up to date

   485

    def GetFilename(self):

   486

        if self.Project is not None:

   487

            if self.ProjectIsSaved():

   488

                return self.FileName

   489

            else:

   490

                return "~%s~" % self.FileName

   491

        return ""

   492