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 plcopen import *

    40

from plcopen.types_enums import *

    42

from plcopen.InstancesPathCollector import InstancesPathCollector

    43

from plcopen.POUVariablesCollector import POUVariablesCollector

    44

from plcopen.InstanceTagnameCollector import InstanceTagnameCollector

    45

from plcopen.VariableInfoCollector import VariableInfoCollector

    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

    54

class LibraryResolver(etree.Resolver):

    55

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

    56

    57

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

    58

        self.Controller = controller

    59

        self.Debug = debug

    60

    61

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

    62

        # TODO stop deepcopy

    63

        lib_name = os.path.basename(url)

    64

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

    65

            lib_el = etree.Element(lib_name)

    66

            if lib_name == "project":

    67

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

    68

            elif lib_name == "stdlib":

    69

                for lib in StdBlckLibs.values():

    70

                    lib_el.append(deepcopy(lib))

    71

            else:

    72

                for ctn in self.Controller.ConfNodeTypes:

    73

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

    74

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

    75

    76

    77

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

    78

#           Helpers object for generating pou block instances list

    79

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

    80

    81

    82

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

    83

    84

_BlockInstanceInfos = namedtuple(

    85

    "BlockInstanceInfos",

    86

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

    87

    88

_BlockSpecificValues = (

    89

    namedtuple("BlockSpecificValues",

    90

               ["name", "execution_order"]),

    91

    [_StringValue, int])

    92

_VariableSpecificValues = (

    93

    namedtuple("VariableSpecificValues",

    94

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

    95

    [_StringValue, _StringValue, int])

    96

_ConnectionSpecificValues = (

    97

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

    98

    [_StringValue])

    99

   100

_PowerRailSpecificValues = (

   101

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

   102

    [int])

   103

   104

_LDElementSpecificValues = (

   105

    namedtuple("LDElementSpecificValues",

   106

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

   107

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

   108

   109

_DivergenceSpecificValues = (

   110

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

   111

    [int])

   112

   113

_SpecificValuesTuples = {

   114

    "comment": (

   115

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

   116

        [_StringValue]),

   117

    "input": _VariableSpecificValues,

   118

    "output": _VariableSpecificValues,

   119

    "inout": _VariableSpecificValues,

   120

    "connector": _ConnectionSpecificValues,

   121

    "continuation": _ConnectionSpecificValues,

   122

    "leftPowerRail": _PowerRailSpecificValues,

   123

    "rightPowerRail": _PowerRailSpecificValues,

   124

    "contact": _LDElementSpecificValues,

   125

    "coil": _LDElementSpecificValues,

   126

    "step": (

   127

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

   128

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

   129

    "transition": (

   130

        namedtuple("TransitionSpecificValues",

   131

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

   132

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

   133

    "selectionDivergence": _DivergenceSpecificValues,

   134

    "selectionConvergence": _DivergenceSpecificValues,

   135

    "simultaneousDivergence": _DivergenceSpecificValues,

   136

    "simultaneousConvergence": _DivergenceSpecificValues,

   137

    "jump": (

   138

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

   139

        [_StringValue]),

   140

    "actionBlock": (

   141

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

   142

        [lambda x: x]),

   143

}

   144

   145

_InstanceConnectionInfos = namedtuple(

   146

    "InstanceConnectionInfos",

   147

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

   148

   149

_ConnectionLinkInfos = namedtuple(

   150

    "ConnectionLinkInfos",

   151

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

   152

   153

   154

class _ActionInfos(object):

   155

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

   156

   157

    def __init__(self, *args):

   158

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

   159

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

   160

   161

    def copy(self):

   162

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

   163

   164

   165

class BlockInstanceFactory(object):

   166

   167

    def __init__(self, block_instances):

   168

        self.BlockInstances = block_instances

   169

        self.CurrentInstance = None

   170

        self.SpecificValues = None

   171

        self.CurrentConnection = None

   172

        self.CurrentLink = None

   173

   174

    def SetSpecificValues(self, context, *args):

   175

        self.SpecificValues = list(args)

   176

        self.CurrentInstance = None

   177

        self.CurrentConnection = None

   178

        self.CurrentLink = None

   179

   180

    def AddBlockInstance(self, context, *args):

   181

        specific_values_tuple, specific_values_translation = \

   182

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

   183

   184

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

   185

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

   186

            self.SpecificValues.append([None])

   187

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

   188

            self.SpecificValues.append([[]])

   189

        specific_values = specific_values_tuple(*_translate_args(

   190

            specific_values_translation, self.SpecificValues))

   191

        self.SpecificValues = None

   192

   193

        self.CurrentInstance = _BlockInstanceInfos(

   194

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

   195

              [specific_values, [], []]))

   196

   197

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

   198

   199

    def AddInstanceConnection(self, context, *args):

   200

        connection_args = _translate_args(

   201

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

   202

   203

        self.CurrentConnection = _InstanceConnectionInfos(

   204

            *(connection_args[1:4] + [

   205

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

   206

   207

        if self.CurrentInstance is not None:

   208

            if connection_args[0] == "input":

   209

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

   210

            else:

   211

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

   212

        else:

   213

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

   214

   215

    def AddConnectionLink(self, context, *args):

   216

        self.CurrentLink = _ConnectionLinkInfos(

   217

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

   218

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

   219

   220

    def AddLinkPoint(self, context, *args):

   221

        self.CurrentLink.points.append(_Point(

   222

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

   223

   224

    def AddAction(self, context, *args):

   225

        if len(self.SpecificValues) == 0:

   226

            self.SpecificValues.append([[]])

   227

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

   228

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

   229

   230

   231

pou_block_instances_xslt = etree.parse(

   232

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

   233

   234

   235

# Length of the buffer

   236

UNDO_BUFFER_LENGTH = 20

   237

   238

   239

class UndoBuffer(object):

   240

    """

   241

    Undo Buffer for PLCOpenEditor

   242

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

   243

    """

   244

   245

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

   246

        """

   247

        Constructor initialising buffer

   248

        """

   249

        self.Buffer = []

   250

        self.CurrentIndex = -1

   251

        self.MinIndex = -1

   252

        self.MaxIndex = -1

   253

        # if current state is defined

   254

        if currentstate:

   255

            self.CurrentIndex = 0

   256

            self.MinIndex = 0

   257

            self.MaxIndex = 0

   258

        # Initialising buffer with currentstate at the first place

   259

        for i in xrange(UNDO_BUFFER_LENGTH):

   260

            if i == 0:

   261

                self.Buffer.append(currentstate)

   262

            else:

   263

                self.Buffer.append(None)

   264

        # Initialising index of state saved

   265

        if issaved:

   266

            self.LastSave = 0

   267

        else:

   268

            self.LastSave = -1

   269

   270

    def Buffering(self, currentstate):

   271

        """

   272

        Add a new state in buffer

   273

        """

   274

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

   275

        self.Buffer[self.CurrentIndex] = currentstate

   276

        # Actualising buffer limits

   277

        self.MaxIndex = self.CurrentIndex

   278

        if self.MinIndex == self.CurrentIndex:

   279

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

   280

            if self.LastSave == self.MinIndex:

   281

                self.LastSave = -1

   282

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

   283

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

   284

   285

    def Current(self):

   286

        """

   287

        Return current state of buffer

   288

        """

   289

        return self.Buffer[self.CurrentIndex]

   290

   291

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

   292

    def Previous(self):

   293

        if self.CurrentIndex != self.MinIndex:

   294

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

   295

            return self.Buffer[self.CurrentIndex]

   296

        return None

   297

   298

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

   299

    def Next(self):

   300

        if self.CurrentIndex != self.MaxIndex:

   301

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

   302

            return self.Buffer[self.CurrentIndex]

   303

        return None

   304

   305

    # Return True if current state is the first in buffer

   306

    def IsFirst(self):

   307

        return self.CurrentIndex == self.MinIndex

   308

   309

    # Return True if current state is the last in buffer

   310

    def IsLast(self):

   311

        return self.CurrentIndex == self.MaxIndex

   312

   313

    # Note that current state is saved

   314

    def CurrentSaved(self):

   315

        self.LastSave = self.CurrentIndex

   316

   317

    # Return True if current state is saved

   318

    def IsCurrentSaved(self):

   319

        return self.LastSave == self.CurrentIndex

   320

   321

   322

class PLCControler(object):

   323

    """

   324

    Controler for PLCOpenEditor

   325

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

   326

    """

   327

   328

    # Create a new PLCControler

   329

    def __init__(self):

   330

        self.LastNewIndex = 0

   331

        self.Reset()

   332

        self.InstancesPathCollector = InstancesPathCollector(self)

   333

        self.POUVariablesCollector = POUVariablesCollector(self)

   334

        self.InstanceTagnameCollector = InstanceTagnameCollector(self)

   335

        self.VariableInfoCollector = VariableInfoCollector(self)

   336

   337

    # Reset PLCControler internal variables

   338

    def Reset(self):

   339

        self.Project = None

   340

        self.ProjectBufferEnabled = True

   341

        self.ProjectBuffer = None

   342

        self.ProjectSaved = True

   343

        self.Buffering = False

   344

        self.FilePath = ""

   345

        self.FileName = ""

   346

        self.ProgramChunks = []

   347

        self.ProgramOffset = 0

   348

        self.NextCompiledProject = None

   349

        self.CurrentCompiledProject = None

   350

        self.ConfNodeTypes = []

   351

        self.TotalTypesDict = StdBlckDct.copy()

   352

        self.TotalTypes = StdBlckLst[:]

   353

        self.ProgramFilePath = ""

   354

   355

    def GetQualifierTypes(self):

   356

        return QualifierList

   357

   358

    def GetProject(self, debug=False):

   359

        if debug and self.CurrentCompiledProject is not None:

   360

            return self.CurrentCompiledProject

   361

        else:

   362

            return self.Project

   363

   364

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

   365

    #                         Project management functions

   366

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

   367

   368

    # Return if a project is opened

   369

    def HasOpenedProject(self):

   370

        return self.Project is not None

   371

   372

    # Create a new project by replacing the current one

   373

    def CreateNewProject(self, properties):

   374

        # Create the project

   375

        self.Project = PLCOpenParser.CreateRoot()

   376

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

   377

        self.Project.setfileHeader(properties)

   378

        self.Project.setcontentHeader(properties)

   379

        self.SetFilePath("")

   380

   381

        # Initialize the project buffer

   382

        self.CreateProjectBuffer(False)

   383

        self.ProgramChunks = []

   384

        self.ProgramOffset = 0

   385

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

   386

        self.CurrentCompiledProject = None

   387

        self.Buffering = False

   388

   389

    # Return project data type names

   390

    def GetProjectDataTypeNames(self, debug=False):

   391

        project = self.GetProject(debug)

   392

        if project is not None:

   393

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

   394

        return []

   395

   396

    # Return project pou names

   397

    def GetProjectPouNames(self, debug=False):

   398

        project = self.GetProject(debug)

   399

        if project is not None:

   400

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

   401

        return []

   402

   403

    # Return project pou names

   404

    def GetProjectConfigNames(self, debug=False):

   405

        project = self.GetProject(debug)

   406

        if project is not None:

   407

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

   408

        return []

   409

   410

    # Return project pou variable names

   411

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

   412

        variables = []

   413

        project = self.GetProject(debug)

   414

        if project is not None:

   415

            for pou in project.getpous():

   416

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

   417

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

   418

                    for transition in pou.gettransitionList():

   419

                        variables.append(transition.getname())

   420

                    for action in pou.getactionList():

   421

                        variables.append(action.getname())

   422

        return variables

   423

   424

    # Return file path if project is an open file

   425

    def GetFilePath(self):

   426

        return self.FilePath

   427

   428

    # Return file path if project is an open file

   429

    def GetProgramFilePath(self):

   430

        return self.ProgramFilePath

   431

   432

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

   433

    def GetFilename(self):

   434

        if self.Project is not None:

   435

            if self.ProjectIsSaved():

   436

                return self.FileName

   437

            else:

   438

                return "~%s~" % self.FileName

   439

        return ""

   440

   441

    # Change file path and save file name or create a default one if file path not defined

   442

    def SetFilePath(self, filepath):

   443

        self.FilePath = filepath

   444

        if filepath == "":

   445

            self.LastNewIndex += 1

   446

            self.FileName = _("Unnamed%d") % self.LastNewIndex

   447

        else:

   448

            self.FileName = os.path.splitext(os.path.basename(filepath))[0]

   449

   450

    # Change project properties

   451

    def SetProjectProperties(self, name=None, properties=None, buffer=True):

   452

        if self.Project is not None:

   453

            if name is not None:

   454

                self.Project.setname(name)

   455

            if properties is not None:

   456

                self.Project.setfileHeader(properties)

   457

                self.Project.setcontentHeader(properties)

   458

            if buffer and (name is not None or properties is not None):

   459

                self.BufferProject()

   460

   461

    # Return project name

   462

    def GetProjectName(self, debug=False):

   463

        project = self.GetProject(debug)

   464

        if project is not None:

   465

            return project.getname()

   466

        return None

   467

   468

    # Return project properties

   469

    def GetProjectProperties(self, debug=False):

   470

        project = self.GetProject(debug)

   471

        if project is not None:

   472

            properties = project.getfileHeader()

   473

            properties.update(project.getcontentHeader())

   474

            return properties

   475

        return None

   476

   477

    # Return project informations

   478

    def GetProjectInfos(self, debug=False):

   479

        project = self.GetProject(debug)

   480

        if project is not None:

   481

            infos = {"name": project.getname(), "type": ITEM_PROJECT}

   482

            datatypes = {"name": DATA_TYPES, "type": ITEM_DATATYPES, "values": []}

   483

            for datatype in project.getdataTypes():

   484

                datatypes["values"].append({

   485

                    "name": datatype.getname(),

   486

                    "type": ITEM_DATATYPE,

   487

                    "tagname": ComputeDataTypeName(datatype.getname()),

   488

                    "values": []})

   489

            pou_types = {

   490

                "function": {

   491

                    "name":   FUNCTIONS,

   492

                    "type":   ITEM_FUNCTION,

   493

                    "values": []

   494

                },