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

    35

import util.paths as paths

    36

from plcopen import *

    37

from plcopen.types_enums import *

    38

from plcopen.InstancesPathCollector import InstancesPathCollector

    39

from plcopen.POUVariablesCollector import POUVariablesCollector

    40

from plcopen.InstanceTagnameCollector import InstanceTagnameCollector

    41

from plcopen.BlockInstanceCollector import BlockInstanceCollector

    42

from plcopen.VariableInfoCollector import VariableInfoCollector

    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

VARIABLE_NAME_SUFFIX_MODEL = re.compile('(\d+)$')

    48

    49

ScriptDirectory = paths.AbsDir(__file__)

    50

    51

# Length of the buffer

    52

UNDO_BUFFER_LENGTH = 20

    53

    54

    55

class UndoBuffer(object):

    56

    """

    57

    Undo Buffer for PLCOpenEditor

    58

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

    59

    """

    60

    61

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

    62

        """

    63

        Constructor initialising buffer

    64

        """

    65

        self.Buffer = []

    66

        self.CurrentIndex = -1

    67

        self.MinIndex = -1

    68

        self.MaxIndex = -1

    69

        # if current state is defined

    70

        if currentstate:

    71

            self.CurrentIndex = 0

    72

            self.MinIndex = 0

    73

            self.MaxIndex = 0

    74

        # Initialising buffer with currentstate at the first place

    75

        for i in xrange(UNDO_BUFFER_LENGTH):

    76

            if i == 0:

    77

                self.Buffer.append(currentstate)

    78

            else:

    79

                self.Buffer.append(None)

    80

        # Initialising index of state saved

    81

        if issaved:

    82

            self.LastSave = 0

    83

        else:

    84

            self.LastSave = -1

    85

    86

    def Buffering(self, currentstate):

    87

        """

    88

        Add a new state in buffer

    89

        """

    90

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

    91

        self.Buffer[self.CurrentIndex] = currentstate

    92

        # Actualising buffer limits

    93

        self.MaxIndex = self.CurrentIndex

    94

        if self.MinIndex == self.CurrentIndex:

    95

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

    96

            if self.LastSave == self.MinIndex:

    97

                self.LastSave = -1

    98

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

    99

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

   100

   101

    def Current(self):

   102

        """

   103

        Return current state of buffer

   104

        """

   105

        return self.Buffer[self.CurrentIndex]

   106

   107

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

   108

    def Previous(self):

   109

        if self.CurrentIndex != self.MinIndex:

   110

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

   111

            return self.Buffer[self.CurrentIndex]

   112

        return None

   113

   114

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

   115

    def Next(self):

   116

        if self.CurrentIndex != self.MaxIndex:

   117

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

   118

            return self.Buffer[self.CurrentIndex]

   119

        return None

   120

   121

    # Return True if current state is the first in buffer

   122

    def IsFirst(self):

   123

        return self.CurrentIndex == self.MinIndex

   124

   125

    # Return True if current state is the last in buffer

   126

    def IsLast(self):

   127

        return self.CurrentIndex == self.MaxIndex

   128

   129

    # Note that current state is saved

   130

    def CurrentSaved(self):

   131

        self.LastSave = self.CurrentIndex

   132

   133

    # Return True if current state is saved

   134

    def IsCurrentSaved(self):

   135

        return self.LastSave == self.CurrentIndex

   136

   137

   138

class PLCControler(object):

   139

    """

   140

    Controler for PLCOpenEditor

   141

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

   142

    """

   143

   144

    # Create a new PLCControler

   145

    def __init__(self):

   146

        self.LastNewIndex = 0

   147

        self.Reset()

   148

        self.InstancesPathCollector = InstancesPathCollector(self)

   149

        self.POUVariablesCollector = POUVariablesCollector(self)

   150

        self.InstanceTagnameCollector = InstanceTagnameCollector(self)

   151

        self.BlockInstanceCollector = BlockInstanceCollector(self)

   152

        self.VariableInfoCollector = VariableInfoCollector(self)

   153

   154

    # Reset PLCControler internal variables

   155

    def Reset(self):

   156

        self.Project = None

   157

        self.ProjectBufferEnabled = True

   158

        self.ProjectBuffer = None

   159

        self.ProjectSaved = True

   160

        self.Buffering = False

   161

        self.FilePath = ""

   162

        self.FileName = ""

   163

        self.ProgramChunks = []

   164

        self.ProgramOffset = 0

   165

        self.NextCompiledProject = None

   166

        self.CurrentCompiledProject = None

   167

        self.ConfNodeTypes = []

   168

        self.TotalTypesDict = StdBlckDct.copy()

   169

        self.TotalTypes = StdBlckLst[:]

   170

        self.ProgramFilePath = ""

   171

   172

    def GetQualifierTypes(self):

   173

        return QualifierList

   174

   175

    def GetProject(self, debug=False):

   176

        if debug and self.CurrentCompiledProject is not None:

   177

            return self.CurrentCompiledProject

   178

        else:

   179

            return self.Project

   180

   181

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

   182

    #                         Project management functions

   183

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

   184

   185

    # Return if a project is opened

   186

    def HasOpenedProject(self):

   187

        return self.Project is not None

   188

   189

    # Create a new project by replacing the current one

   190

    def CreateNewProject(self, properties):

   191

        # Create the project

   192

        self.Project = PLCOpenParser.CreateRoot()

   193

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

   194

        self.Project.setfileHeader(properties)

   195

        self.Project.setcontentHeader(properties)

   196

        self.SetFilePath("")

   197

   198

        # Initialize the project buffer

   199

        self.CreateProjectBuffer(False)

   200

        self.ProgramChunks = []

   201

        self.ProgramOffset = 0

   202

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

   203

        self.CurrentCompiledProject = None

   204

        self.Buffering = False

   205

   206

    # Return project data type names

   207

    def GetProjectDataTypeNames(self, debug=False):

   208

        project = self.GetProject(debug)

   209

        if project is not None:

   210

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

   211

        return []

   212

   213

    # Return project pou names

   214

    def GetProjectPouNames(self, debug=False):

   215

        project = self.GetProject(debug)

   216

        if project is not None:

   217

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

   218

        return []

   219

   220

    # Return project pou names

   221

    def GetProjectConfigNames(self, debug=False):

   222

        project = self.GetProject(debug)

   223

        if project is not None:

   224

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

   225

        return []

   226

   227

    # Return project pou variable names

   228

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

   229

        variables = []

   230

        project = self.GetProject(debug)

   231

        if project is not None:

   232

            for pou in project.getpous():

   233

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

   234

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

   235

                    for transition in pou.gettransitionList():

   236

                        variables.append(transition.getname())

   237

                    for action in pou.getactionList():

   238

                        variables.append(action.getname())

   239

        return variables

   240

   241

    # Return file path if project is an open file

   242

    def GetFilePath(self):

   243

        return self.FilePath

   244

   245

    # Return file path if project is an open file

   246

    def GetProgramFilePath(self):

   247

        return self.ProgramFilePath

   248

   249

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

   250

    def GetFilename(self):

   251

        if self.Project is not None:

   252

            if self.ProjectIsSaved():

   253

                return self.FileName

   254

            else:

   255

                return "~%s~" % self.FileName

   256

        return ""

   257

   258

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

   259

    def SetFilePath(self, filepath):

   260

        self.FilePath = filepath

   261

        if filepath == "":

   262

            self.LastNewIndex += 1

   263

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

   264

        else:

   265

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

   266

   267

    # Change project properties

   268

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

   269

        if self.Project is not None:

   270

            if name is not None:

   271

                self.Project.setname(name)

   272

            if properties is not None:

   273

                self.Project.setfileHeader(properties)

   274

                self.Project.setcontentHeader(properties)

   275

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

   276

                self.BufferProject()

   277

   278

    # Return project name

   279

    def GetProjectName(self, debug=False):

   280

        project = self.GetProject(debug)

   281

        if project is not None:

   282

            return project.getname()

   283

        return None

   284

   285

    # Return project properties

   286

    def GetProjectProperties(self, debug=False):

   287

        project = self.GetProject(debug)

   288

        if project is not None:

   289

            properties = project.getfileHeader()

   290

            properties.update(project.getcontentHeader())

   291

            return properties

   292

        return None

   293

   294

    # Return project informations

   295

    def GetProjectInfos(self, debug=False):

   296

        project = self.GetProject(debug)

   297

        if project is not None:

   298

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

   299

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

   300

            for datatype in project.getdataTypes():

   301

                datatypes["values"].append({

   302

                    "name": datatype.getname(),

   303

                    "type": ITEM_DATATYPE,

   304

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

   305

                    "values": []})

   306

            pou_types = {

   307

                "function": {

   308

                    "name":   FUNCTIONS,

   309

                    "type":   ITEM_FUNCTION,

   310

                    "values": []

   311

                },

   312

                "functionBlock": {

   313

                    "name":   FUNCTION_BLOCKS,

   314

                    "type":   ITEM_FUNCTIONBLOCK,

   315

                    "values": []

   316

                },

   317

                "program": {

   318

                    "name":   PROGRAMS,

   319

                    "type":   ITEM_PROGRAM,

   320

                    "values": []

   321

                }

   322

            }

   323

            for pou in project.getpous():

   324

                pou_type = pou.getpouType()

   325

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

   326

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

   327

                pou_values = []

   328

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

   329

                    transitions = []

   330

                    for transition in pou.gettransitionList():

   331

                        transitions.append({

   332

                            "name": transition.getname(),

   333

                            "type": ITEM_TRANSITION,

   334

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

   335

                            "values": []})

   336

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

   337

                    actions = []

   338

                    for action in pou.getactionList():

   339

                        actions.append({

   340

                            "name": action.getname(),

   341

                            "type": ITEM_ACTION,

   342

                            "tagname": ComputePouActionName(pou.getname(), action.getname()),

   343

                            "values": []})

   344

                    pou_values.append({"name": ACTIONS, "type": ITEM_ACTIONS, "values": actions})

   345

                if pou_type in pou_types:

   346

                    pou_infos["values"] = pou_values

   347

                    pou_types[pou_type]["values"].append(pou_infos)

   348

            configurations = {"name": CONFIGURATIONS, "type": ITEM_CONFIGURATIONS, "values": []}

   349

            for config in project.getconfigurations():

   350

                config_name = config.getname()

   351

                config_infos = {

   352

                    "name": config_name,

   353

                    "type": ITEM_CONFIGURATION,

   354

                    "tagname": ComputeConfigurationName(config.getname()),

   355

                    "values": []}

   356

                resources = {"name": RESOURCES, "type": ITEM_RESOURCES, "values": []}

   357

                for resource in config.getresource():

   358

                    resource_name = resource.getname()

   359

                    resource_infos = {

   360

                        "name": resource_name,

   361

                        "type": ITEM_RESOURCE,

   362

                        "tagname": ComputeConfigurationResourceName(config.getname(), resource.getname()),

   363

                        "values": []}

   364

                    resources["values"].append(resource_infos)

   365

                config_infos["values"] = [resources]

   366

                configurations["values"].append(config_infos)

   367

            infos["values"] = [datatypes, pou_types["function"], pou_types["functionBlock"],

   368

                               pou_types["program"], configurations]

   369

            return infos

   370

        return None

   371

   372

    def GetPouVariables(self, tagname, debug=False):

   373

        project = self.GetProject(debug)

   374

        if project is not None:

   375

            obj = None

   376

            words = tagname.split("::")

   377

            if words[0] == "P":

   378

                obj = self.GetPou(words[1], debug)

   379

            elif words[0] != "D":

   380

                obj = self.GetEditedElement(tagname, debug)

   381

            if obj is not None:

   382

                return self.POUVariablesCollector.Collect(obj, debug)

   383

   384

        return None

   385

   386

    def GetInstanceList(self, root, name, debug=False):

   387

        return self.InstancesPathCollector.Collect(root, name, debug)

   388

   389

    def SearchPouInstances(self, tagname, debug=False):

   390

        project = self.GetProject(debug)

   391

        if project is not None:

   392

            words = tagname.split("::")

   393

            if words[0] == "P":

   394

                return self.GetInstanceList(project, words[1])

   395

            elif words[0] == 'C':

   396

                return [words[1]]

   397

            elif words[0] == 'R':

   398

                return ["%s.%s" % (words[1], words[2])]

   399

            elif words[0] in ['T', 'A']:

   400

                return ["%s.%s" % (instance, words[2])

   401

                        for instance in self.SearchPouInstances(

   402

                            ComputePouName(words[1]), debug)]

   403

        return []

   404

   405

    def GetPouInstanceTagName(self, instance_path, debug=False):

   406

        project = self.GetProject(debug)

   407

        if project is not None:

   408

            return self.InstanceTagnameCollector.Collect(project,

   409

                                                         debug,

   410

                                                         instance_path)

   411

   412

    def GetInstanceInfos(self, instance_path, debug=False):

   413

        tagname = self.GetPouInstanceTagName(instance_path)

   414

        if tagname is not None:

   415

            infos = self.GetPouVariables(tagname, debug)

   416

            infos.type = tagname

   417

            return infos

   418

        else:

   419

            pou_path, var_name = instance_path.rsplit(".", 1)

   420

            tagname = self.GetPouInstanceTagName(pou_path)

   421

            if tagname is not None:

   422

                pou_infos = self.GetPouVariables(tagname, debug)

   423

                for var_infos in pou_infos.variables:

   424

                    if var_infos.name == var_name:

   425

                        return var_infos

   426

        return None

   427

   428

    # Return if data type given by name is used by another data type or pou

   429

    def DataTypeIsUsed(self, name, debug=False):

   430

        project = self.GetProject(debug)

   431

        if project is not None:

   432

            return len(self.GetInstanceList(project, name, debug)) > 0

   433

        return False

   434

   435

    # Return if pou given by name is used by another pou

   436

    def PouIsUsed(self, name, debug=False):

   437

        project = self.GetProject(debug)

   438

        if project is not None:

   439

            return len(self.GetInstanceList(project, name, debug)) > 0

   440

        return False

   441

   442

    # Return if pou given by name is directly or undirectly used by the reference pou

   443

    def PouIsUsedBy(self, name, reference, debug=False):

   444

        pou_infos = self.GetPou(reference, debug)

   445

        if pou_infos is not None:

   446

            return len(self.GetInstanceList(pou_infos, name, debug)) > 0

   447

        return False

   448

   449

    def GenerateProgram(self, filepath=None):

   450

        errors = []

   451

        warnings = []

   452

        if self.Project is not None:

   453

            try:

   454

                self.ProgramChunks = GenerateCurrentProgram(self, self.Project, errors, warnings)

   455

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

   456

                program_text = "".join([item[0] for item in self.ProgramChunks])

   457

                if filepath is not None:

   458

                    programfile = open(filepath, "w")

   459

                    programfile.write(program_text.encode("utf-8"))

   460

                    programfile.close()

   461

                    self.ProgramFilePath = filepath

   462

                return program_text, errors, warnings

   463

            except PLCGenException, ex:

   464

                errors.append(ex.message)

   465

        else:

   466

            errors.append("No project opened")

   467

        return "", errors, warnings

   468

   469

    def DebugAvailable(self):

   470

        return self.CurrentCompiledProject is not None

   471

   472

    def ProgramTransferred(self):

   473

        if self.NextCompiledProject is None:

   474

            self.CurrentCompiledProject = self.NextCompiledProject

   475

        else:

   476

            self.CurrentCompiledProject = self.Copy(self.Project)

   477

   478

    def GetChunkInfos(self, from_location, to_location):

   479

        row = self.ProgramOffset + 1

   480

        col = 1

   481

        infos = []

   482

        for chunk, chunk_infos in self.ProgramChunks:

   483

            lines = chunk.split("\n")

   484

            if len(lines) > 1:

   485

                next_row = row + len(lines) - 1

   486

                next_col = len(lines[-1]) + 1

   487

            else:

   488

                next_row = row

   489

                next_col = col + len(chunk)

   490

            if (next_row > from_location[0] or next_row == from_location[0] and next_col >= from_location[1]) and len(chunk_infos) > 0:

   491

                infos.append((chunk_infos, (row, col)))

   492

            if next_row == to_location[0] and next_col > to_location[1] or next_row > to_location[0]:

   493

                return infos

   494

            row, col = next_row, next_col

   495

        return infos

   496

   497

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

   498

    #                        Project Pous management functions

   499

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

   500

   501

    # Add a Data Type to Project

   502