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 *

    41

from plcopen.XSLTModelQuery import _StringValue, _BoolValue, _translate_args

    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

    53

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

    54

#           Helpers object for generating pou block instances list

    55

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

    56

    57

    58

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

    59

    60

_BlockInstanceInfos = namedtuple(

    61

    "BlockInstanceInfos",

    62

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

    63

    64

_BlockSpecificValues = (

    65

    namedtuple("BlockSpecificValues",

    66

               ["name", "execution_order"]),

    67

    [_StringValue, int])

    68

_VariableSpecificValues = (

    69

    namedtuple("VariableSpecificValues",

    70

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

    71

    [_StringValue, _StringValue, int])

    72

_ConnectionSpecificValues = (

    73

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

    74

    [_StringValue])

    75

    76

_PowerRailSpecificValues = (

    77

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

    78

    [int])

    79

    80

_LDElementSpecificValues = (

    81

    namedtuple("LDElementSpecificValues",

    82

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

    83

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

    84

    85

_DivergenceSpecificValues = (

    86

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

    87

    [int])

    88

    89

_SpecificValuesTuples = {

    90

    "comment": (

    91

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

    92

        [_StringValue]),

    93

    "input": _VariableSpecificValues,

    94

    "output": _VariableSpecificValues,

    95

    "inout": _VariableSpecificValues,

    96

    "connector": _ConnectionSpecificValues,

    97

    "continuation": _ConnectionSpecificValues,

    98

    "leftPowerRail": _PowerRailSpecificValues,

    99

    "rightPowerRail": _PowerRailSpecificValues,

   100

    "contact": _LDElementSpecificValues,

   101

    "coil": _LDElementSpecificValues,

   102

    "step": (

   103

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

   104

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

   105

    "transition": (

   106

        namedtuple("TransitionSpecificValues",

   107

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

   108

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

   109

    "selectionDivergence": _DivergenceSpecificValues,

   110

    "selectionConvergence": _DivergenceSpecificValues,

   111

    "simultaneousDivergence": _DivergenceSpecificValues,

   112

    "simultaneousConvergence": _DivergenceSpecificValues,

   113

    "jump": (

   114

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

   115

        [_StringValue]),

   116

    "actionBlock": (

   117

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

   118

        [lambda x: x]),

   119

}

   120

   121

_InstanceConnectionInfos = namedtuple(

   122

    "InstanceConnectionInfos",

   123

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

   124

   125

_ConnectionLinkInfos = namedtuple(

   126

    "ConnectionLinkInfos",

   127

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

   128

   129

   130

class _ActionInfos(object):

   131

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

   132

   133

    def __init__(self, *args):

   134

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

   135

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

   136

   137

    def copy(self):

   138

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

   139

   140

   141

class BlockInstanceFactory(object):

   142

   143

    def __init__(self, block_instances):

   144

        self.BlockInstances = block_instances

   145

        self.CurrentInstance = None

   146

        self.SpecificValues = None

   147

        self.CurrentConnection = None

   148

        self.CurrentLink = None

   149

   150

    def SetSpecificValues(self, context, *args):

   151

        self.SpecificValues = list(args)

   152

        self.CurrentInstance = None

   153

        self.CurrentConnection = None

   154

        self.CurrentLink = None

   155

   156

    def AddBlockInstance(self, context, *args):

   157

        specific_values_tuple, specific_values_translation = \

   158

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

   159

   160

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

   161

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

   162

            self.SpecificValues.append([None])

   163

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

   164

            self.SpecificValues.append([[]])

   165

        specific_values = specific_values_tuple(*_translate_args(

   166

            specific_values_translation, self.SpecificValues))

   167

        self.SpecificValues = None

   168

   169

        self.CurrentInstance = _BlockInstanceInfos(

   170

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

   171

              [specific_values, [], []]))

   172

   173

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

   174

   175

    def AddInstanceConnection(self, context, *args):

   176

        connection_args = _translate_args(

   177

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

   178

   179

        self.CurrentConnection = _InstanceConnectionInfos(

   180

            *(connection_args[1:4] + [

   181

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

   182

   183

        if self.CurrentInstance is not None:

   184

            if connection_args[0] == "input":

   185

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

   186

            else:

   187

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

   188

        else:

   189

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

   190

   191

    def AddConnectionLink(self, context, *args):

   192

        self.CurrentLink = _ConnectionLinkInfos(

   193

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

   194

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

   195

   196

    def AddLinkPoint(self, context, *args):

   197

        self.CurrentLink.points.append(_Point(

   198

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

   199

   200

    def AddAction(self, context, *args):

   201

        if len(self.SpecificValues) == 0:

   202

            self.SpecificValues.append([[]])

   203

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

   204

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

   205

   206

   207

pou_block_instances_xslt = etree.parse(

   208

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

   209

   210

   211

# Length of the buffer

   212

UNDO_BUFFER_LENGTH = 20

   213

   214

   215

class UndoBuffer(object):

   216

    """

   217

    Undo Buffer for PLCOpenEditor

   218

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

   219

    """

   220

   221

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

   222

        """

   223

        Constructor initialising buffer

   224

        """

   225

        self.Buffer = []

   226

        self.CurrentIndex = -1

   227

        self.MinIndex = -1

   228

        self.MaxIndex = -1

   229

        # if current state is defined

   230

        if currentstate:

   231

            self.CurrentIndex = 0

   232

            self.MinIndex = 0

   233

            self.MaxIndex = 0

   234

        # Initialising buffer with currentstate at the first place

   235

        for i in xrange(UNDO_BUFFER_LENGTH):

   236

            if i == 0:

   237

                self.Buffer.append(currentstate)

   238

            else:

   239

                self.Buffer.append(None)

   240

        # Initialising index of state saved

   241

        if issaved:

   242

            self.LastSave = 0

   243

        else:

   244

            self.LastSave = -1

   245

   246

    def Buffering(self, currentstate):

   247

        """

   248

        Add a new state in buffer

   249

        """

   250

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

   251

        self.Buffer[self.CurrentIndex] = currentstate

   252

        # Actualising buffer limits

   253

        self.MaxIndex = self.CurrentIndex

   254

        if self.MinIndex == self.CurrentIndex:

   255

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

   256

            if self.LastSave == self.MinIndex:

   257

                self.LastSave = -1

   258

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

   259

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

   260

   261

    def Current(self):

   262

        """

   263

        Return current state of buffer

   264

        """

   265

        return self.Buffer[self.CurrentIndex]

   266

   267

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

   268

    def Previous(self):

   269

        if self.CurrentIndex != self.MinIndex:

   270

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

   271

            return self.Buffer[self.CurrentIndex]

   272

        return None

   273

   274

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

   275

    def Next(self):

   276

        if self.CurrentIndex != self.MaxIndex:

   277

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

   278

            return self.Buffer[self.CurrentIndex]

   279

        return None

   280

   281

    # Return True if current state is the first in buffer

   282

    def IsFirst(self):

   283

        return self.CurrentIndex == self.MinIndex

   284

   285

    # Return True if current state is the last in buffer

   286

    def IsLast(self):

   287

        return self.CurrentIndex == self.MaxIndex

   288

   289

    # Note that current state is saved

   290

    def CurrentSaved(self):

   291

        self.LastSave = self.CurrentIndex

   292

   293

    # Return True if current state is saved

   294

    def IsCurrentSaved(self):

   295

        return self.LastSave == self.CurrentIndex

   296

   297

   298

class PLCControler(object):

   299

    """

   300

    Controler for PLCOpenEditor

   301

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

   302

    """

   303

   304

    # Create a new PLCControler

   305

    def __init__(self):

   306

        self.LastNewIndex = 0

   307

        self.Reset()

   308

        self.InstancesPathCollector = InstancesPathCollector(self)

   309

        self.POUVariablesCollector = POUVariablesCollector(self)

   310

        self.InstanceTagnameCollector = InstanceTagnameCollector(self)

   311

        self.VariableInfoCollector = VariableInfoCollector(self)

   312

   313

    # Reset PLCControler internal variables

   314

    def Reset(self):

   315

        self.Project = None

   316

        self.ProjectBufferEnabled = True

   317

        self.ProjectBuffer = None

   318

        self.ProjectSaved = True

   319

        self.Buffering = False

   320

        self.FilePath = ""

   321

        self.FileName = ""

   322

        self.ProgramChunks = []

   323

        self.ProgramOffset = 0

   324

        self.NextCompiledProject = None

   325

        self.CurrentCompiledProject = None

   326

        self.ConfNodeTypes = []

   327

        self.TotalTypesDict = StdBlckDct.copy()

   328

        self.TotalTypes = StdBlckLst[:]

   329

        self.ProgramFilePath = ""

   330

   331

    def GetQualifierTypes(self):

   332

        return QualifierList

   333

   334

    def GetProject(self, debug=False):

   335

        if debug and self.CurrentCompiledProject is not None:

   336

            return self.CurrentCompiledProject

   337

        else:

   338

            return self.Project

   339

   340

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

   341

    #                         Project management functions

   342

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

   343

   344

    # Return if a project is opened

   345

    def HasOpenedProject(self):

   346

        return self.Project is not None

   347

   348

    # Create a new project by replacing the current one

   349

    def CreateNewProject(self, properties):

   350

        # Create the project

   351

        self.Project = PLCOpenParser.CreateRoot()

   352

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

   353

        self.Project.setfileHeader(properties)

   354

        self.Project.setcontentHeader(properties)

   355

        self.SetFilePath("")

   356

   357

        # Initialize the project buffer

   358

        self.CreateProjectBuffer(False)

   359

        self.ProgramChunks = []

   360

        self.ProgramOffset = 0

   361

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

   362

        self.CurrentCompiledProject = None

   363

        self.Buffering = False

   364

   365

    # Return project data type names

   366

    def GetProjectDataTypeNames(self, debug=False):

   367

        project = self.GetProject(debug)

   368

        if project is not None:

   369

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

   370

        return []

   371

   372

    # Return project pou names

   373

    def GetProjectPouNames(self, debug=False):

   374

        project = self.GetProject(debug)

   375

        if project is not None:

   376

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

   377

        return []

   378

   379

    # Return project pou names

   380

    def GetProjectConfigNames(self, debug=False):

   381

        project = self.GetProject(debug)

   382

        if project is not None:

   383

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

   384

        return []

   385

   386

    # Return project pou variable names

   387

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

   388

        variables = []

   389

        project = self.GetProject(debug)

   390

        if project is not None:

   391

            for pou in project.getpous():

   392

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

   393

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

   394

                    for transition in pou.gettransitionList():

   395

                        variables.append(transition.getname())

   396

                    for action in pou.getactionList():

   397

                        variables.append(action.getname())

   398

        return variables

   399

   400

    # Return file path if project is an open file

   401

    def GetFilePath(self):

   402

        return self.FilePath

   403

   404

    # Return file path if project is an open file

   405

    def GetProgramFilePath(self):

   406

        return self.ProgramFilePath

   407

   408

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

   409

    def GetFilename(self):

   410

        if self.Project is not None:

   411

            if self.ProjectIsSaved():

   412

                return self.FileName

   413

            else:

   414

                return "~%s~" % self.FileName

   415

        return ""

   416

   417

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

   418

    def SetFilePath(self, filepath):

   419

        self.FilePath = filepath

   420

        if filepath == "":

   421

            self.LastNewIndex += 1

   422

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

   423

        else:

   424

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

   425

   426

    # Change project properties

   427

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

   428

        if self.Project is not None:

   429

            if name is not None:

   430

                self.Project.setname(name)

   431

            if properties is not None:

   432

                self.Project.setfileHeader(properties)

   433

                self.Project.setcontentHeader(properties)

   434

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

   435

                self.BufferProject()

   436

   437

    # Return project name

   438

    def GetProjectName(self, debug=False):

   439

        project = self.GetProject(debug)

   440

        if project is not None:

   441

            return project.getname()

   442

        return None

   443

   444

    # Return project properties

   445

    def GetProjectProperties(self, debug=False):

   446

        project = self.GetProject(debug)

   447

        if project is not None:

   448

            properties = project.getfileHeader()

   449

            properties.update(project.getcontentHeader())

   450

            return properties

   451

        return None

   452

   453

    # Return project informations

   454

    def GetProjectInfos(self, debug=False):

   455

        project = self.GetProject(debug)

   456

        if project is not None:

   457

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

   458

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

   459

            for datatype in project.getdataTypes():

   460

                datatypes["values"].append({

   461

                    "name": datatype.getname(),

   462

                    "type": ITEM_DATATYPE,

   463

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

   464

                    "values": []})

   465

            pou_types = {

   466

                "function": {

   467

                    "name":   FUNCTIONS,

   468

                    "type":   ITEM_FUNCTION,

   469

                    "values": []

   470

                },

   471

                "functionBlock": {

   472

                    "name":   FUNCTION_BLOCKS,

   473

                    "type":   ITEM_FUNCTIONBLOCK,

   474

                    "values": []

   475

                },

   476

                "program": {

   477

                    "name":   PROGRAMS,

   478

                    "type":   ITEM_PROGRAM,

   479

                    "values": []

   480

                }

   481

            }

   482

            for pou in project.getpous():

   483

                pou_type = pou.getpouType()

   484

                pou_infos = {"name": pou.getname(), "type": ITEM_POU,

   485

                             "tagname": ComputePouName(pou.getname())}

   486

                pou_values = []

   487

                if pou.getbodyType() == "SFC":

   488

                    transitions = []

   489

                    for transition in pou.gettransitionList():

   490

                        transitions.append({

   491

                            "name": transition.getname(),

   492

                            "type": ITEM_TRANSITION,

   493

                            "tagname": ComputePouTransitionName(pou.getname(), transition.getname()),

   494

                            "values": []})

   495

                    pou_values.append({"name": TRANSITIONS, "type": ITEM_TRANSITIONS, "values": transitions})