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 __future__ import division

    29

from copy import deepcopy

    30

import os

    31

import re

    32

import datetime

    33

from time import localtime

    34

from functools import reduce

    35

from future.builtins import round

    36

    37

import util.paths as paths

    38

from plcopen import *

    39

from plcopen.types_enums import *

    40

from plcopen.InstancesPathCollector import InstancesPathCollector

    41

from plcopen.POUVariablesCollector import POUVariablesCollector

    42

from plcopen.InstanceTagnameCollector import InstanceTagnameCollector

    43

from plcopen.BlockInstanceCollector import BlockInstanceCollector

    44

from plcopen.VariableInfoCollector import VariableInfoCollector

    45

from graphics.GraphicCommons import *

    46

from PLCGenerator import *

    47

    48

duration_model = re.compile(r"(?:([0-9]{1,2})h)?(?:([0-9]{1,2})m(?!s))?(?:([0-9]{1,2})s)?(?:([0-9]{1,3}(?:\.[0-9]*)?)ms)?")

    49

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

    50

    51

ScriptDirectory = paths.AbsDir(__file__)

    52

    53

# Length of the buffer

    54

UNDO_BUFFER_LENGTH = 20

    55

    56

    57

class UndoBuffer(object):

    58

    """

    59

    Undo Buffer for PLCOpenEditor

    60

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

    61

    """

    62

    63

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

    64

        """

    65

        Constructor initialising buffer

    66

        """

    67

        self.Buffer = []

    68

        self.CurrentIndex = -1

    69

        self.MinIndex = -1

    70

        self.MaxIndex = -1

    71

        # if current state is defined

    72

        if currentstate:

    73

            self.CurrentIndex = 0

    74

            self.MinIndex = 0

    75

            self.MaxIndex = 0

    76

        # Initialising buffer with currentstate at the first place

    77

        for i in xrange(UNDO_BUFFER_LENGTH):

    78

            if i == 0:

    79

                self.Buffer.append(currentstate)

    80

            else:

    81

                self.Buffer.append(None)

    82

        # Initialising index of state saved

    83

        if issaved:

    84

            self.LastSave = 0

    85

        else:

    86

            self.LastSave = -1

    87

    88

    def Buffering(self, currentstate):

    89

        """

    90

        Add a new state in buffer

    91

        """

    92

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

    93

        self.Buffer[self.CurrentIndex] = currentstate

    94

        # Actualising buffer limits

    95

        self.MaxIndex = self.CurrentIndex

    96

        if self.MinIndex == self.CurrentIndex:

    97

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

    98

            if self.LastSave == self.MinIndex:

    99

                self.LastSave = -1

   100

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

   101

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

   102

   103

    def Current(self):

   104

        """

   105

        Return current state of buffer

   106

        """

   107

        return self.Buffer[self.CurrentIndex]

   108

   109

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

   110

    def Previous(self):

   111

        if self.CurrentIndex != self.MinIndex:

   112

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

   113

            return self.Buffer[self.CurrentIndex]

   114

        return None

   115

   116

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

   117

    def Next(self):

   118

        if self.CurrentIndex != self.MaxIndex:

   119

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

   120

            return self.Buffer[self.CurrentIndex]

   121

        return None

   122

   123

    # Return True if current state is the first in buffer

   124

    def IsFirst(self):

   125

        return self.CurrentIndex == self.MinIndex

   126

   127

    # Return True if current state is the last in buffer

   128

    def IsLast(self):

   129

        return self.CurrentIndex == self.MaxIndex

   130

   131

    # Note that current state is saved

   132

    def CurrentSaved(self):

   133

        self.LastSave = self.CurrentIndex

   134

   135

    # Return True if current state is saved

   136

    def IsCurrentSaved(self):

   137

        return self.LastSave == self.CurrentIndex

   138

   139

   140

class PLCControler(object):

   141

    """

   142

    Controler for PLCOpenEditor

   143

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

   144

    """

   145

   146

    # Create a new PLCControler

   147

    def __init__(self):

   148

        self.LastNewIndex = 0

   149

        self.Reset()

   150

        self.InstancesPathCollector = InstancesPathCollector(self)

   151

        self.POUVariablesCollector = POUVariablesCollector(self)

   152

        self.InstanceTagnameCollector = InstanceTagnameCollector(self)

   153

        self.BlockInstanceCollector = BlockInstanceCollector(self)

   154

        self.VariableInfoCollector = VariableInfoCollector(self)

   155

   156

    # Reset PLCControler internal variables

   157

    def Reset(self):

   158

        self.Project = None

   159

        self.ProjectBufferEnabled = True

   160

        self.ProjectBuffer = None

   161

        self.ProjectSaved = True

   162

        self.Buffering = False

   163

        self.FilePath = ""

   164

        self.FileName = ""

   165

        self.ProgramChunks = []

   166

        self.ProgramOffset = 0

   167

        self.NextCompiledProject = None

   168

        self.CurrentCompiledProject = None

   169

        self.ConfNodeTypes = []

   170

        self.TotalTypesDict = StdBlckDct.copy()

   171

        self.TotalTypes = StdBlckLst[:]

   172

        self.ProgramFilePath = ""

   173

   174

    def GetQualifierTypes(self):

   175

        return QualifierList

   176

   177

    def GetProject(self, debug=False):

   178

        if debug and self.CurrentCompiledProject is not None:

   179

            return self.CurrentCompiledProject

   180

        else:

   181

            return self.Project

   182

   183

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

   184

    #                         Project management functions

   185

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

   186

   187

    # Return if a project is opened

   188

    def HasOpenedProject(self):

   189

        return self.Project is not None

   190

   191

    # Create a new project by replacing the current one

   192

    def CreateNewProject(self, properties):

   193

        # Create the project

   194

        self.Project = PLCOpenParser.CreateRoot()

   195

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

   196

        self.Project.setfileHeader(properties)

   197

        self.Project.setcontentHeader(properties)

   198

        self.SetFilePath("")

   199

   200

        # Initialize the project buffer

   201

        self.CreateProjectBuffer(False)

   202

        self.ProgramChunks = []

   203

        self.ProgramOffset = 0

   204

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

   205

        self.CurrentCompiledProject = None

   206

        self.Buffering = False

   207

   208

    # Return project data type names

   209

    def GetProjectDataTypeNames(self, debug=False):

   210

        project = self.GetProject(debug)

   211

        if project is not None:

   212

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

   213

        return []

   214

   215

    # Return project pou names

   216

    def GetProjectPouNames(self, debug=False):

   217

        project = self.GetProject(debug)

   218

        if project is not None:

   219

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

   220

        return []

   221

   222

    # Return project pou names

   223

    def GetProjectConfigNames(self, debug=False):

   224

        project = self.GetProject(debug)

   225

        if project is not None:

   226

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

   227

        return []

   228

   229

    # Return project pou variable names

   230

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

   231

        variables = []

   232

        project = self.GetProject(debug)

   233

        if project is not None:

   234

            for pou in project.getpous():

   235

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

   236

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

   237

                    for transition in pou.gettransitionList():

   238

                        variables.append(transition.getname())

   239

                    for action in pou.getactionList():

   240

                        variables.append(action.getname())

   241

        return variables

   242

   243

    # Return file path if project is an open file

   244

    def GetFilePath(self):

   245

        return self.FilePath

   246

   247

    # Return file path if project is an open file

   248

    def GetProgramFilePath(self):

   249

        return self.ProgramFilePath

   250

   251

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

   252

    def GetFilename(self):

   253

        if self.Project is not None:

   254

            if self.ProjectIsSaved():

   255

                return self.FileName

   256

            else:

   257

                return "~%s~" % self.FileName

   258

        return ""

   259

   260

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

   261

    def SetFilePath(self, filepath):

   262

        self.FilePath = filepath

   263

        if filepath == "":

   264

            self.LastNewIndex += 1

   265

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

   266

        else:

   267

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

   268

   269

    # Change project properties

   270

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

   271

        if self.Project is not None:

   272

            if name is not None:

   273

                self.Project.setname(name)

   274

            if properties is not None:

   275

                self.Project.setfileHeader(properties)

   276

                self.Project.setcontentHeader(properties)

   277

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

   278

                self.BufferProject()

   279

   280

    # Return project name

   281

    def GetProjectName(self, debug=False):

   282

        project = self.GetProject(debug)

   283

        if project is not None:

   284

            return project.getname()

   285

        return None

   286

   287

    # Return project properties

   288

    def GetProjectProperties(self, debug=False):

   289

        project = self.GetProject(debug)

   290

        if project is not None:

   291

            properties = project.getfileHeader()

   292

            properties.update(project.getcontentHeader())

   293

            return properties

   294

        return None

   295

   296

    # Return project informations

   297

    def GetProjectInfos(self, debug=False):

   298

        project = self.GetProject(debug)

   299

        if project is not None:

   300

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

   301

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

   302

            for datatype in project.getdataTypes():

   303

                datatypes["values"].append({

   304

                    "name": datatype.getname(),

   305

                    "type": ITEM_DATATYPE,

   306

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

   307

                    "values": []})

   308

            pou_types = {

   309

                "function": {

   310

                    "name":   FUNCTIONS,

   311

                    "type":   ITEM_FUNCTION,

   312

                    "values": []

   313

                },

   314

                "functionBlock": {

   315

                    "name":   FUNCTION_BLOCKS,

   316

                    "type":   ITEM_FUNCTIONBLOCK,

   317

                    "values": []

   318

                },

   319

                "program": {

   320

                    "name":   PROGRAMS,

   321

                    "type":   ITEM_PROGRAM,

   322

                    "values": []

   323

                }

   324

            }

   325

            for pou in project.getpous():

   326

                pou_type = pou.getpouType()

   327

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

   328

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

   329

                pou_values = []

   330

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

   331

                    transitions = []

   332

                    for transition in pou.gettransitionList():

   333

                        transitions.append({

   334

                            "name": transition.getname(),

   335

                            "type": ITEM_TRANSITION,

   336

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

   337

                            "values": []})

   338

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

   339

                    actions = []

   340

                    for action in pou.getactionList():

   341

                        actions.append({

   342

                            "name": action.getname(),

   343

                            "type": ITEM_ACTION,

   344

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

   345

                            "values": []})

   346

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

   347

                if pou_type in pou_types:

   348

                    pou_infos["values"] = pou_values

   349

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

   350

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

   351

            for config in project.getconfigurations():

   352

                config_name = config.getname()

   353

                config_infos = {

   354

                    "name": config_name,

   355

                    "type": ITEM_CONFIGURATION,

   356

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

   357

                    "values": []}

   358

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

   359

                for resource in config.getresource():

   360

                    resource_name = resource.getname()

   361

                    resource_infos = {

   362

                        "name": resource_name,

   363

                        "type": ITEM_RESOURCE,

   364

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

   365

                        "values": []}

   366

                    resources["values"].append(resource_infos)

   367

                config_infos["values"] = [resources]

   368

                configurations["values"].append(config_infos)

   369

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

   370

                               pou_types["program"], configurations]

   371

            return infos

   372

        return None

   373

   374

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

   375

        project = self.GetProject(debug)

   376

        if project is not None:

   377

            obj = None

   378

            words = tagname.split("::")

   379

            if words[0] == "P":

   380

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

   381

            elif words[0] != "D":

   382

                obj = self.GetEditedElement(tagname, debug)

   383

            if obj is not None:

   384

                return self.POUVariablesCollector.Collect(obj, debug)

   385

   386

        return None

   387

   388

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

   389

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

   390

   391

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

   392

        project = self.GetProject(debug)

   393

        if project is not None:

   394

            words = tagname.split("::")

   395

            if words[0] == "P":

   396

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

   397

            elif words[0] == 'C':

   398

                return [words[1]]

   399

            elif words[0] == 'R':

   400

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

   401

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

   402

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

   403

                        for instance in self.SearchPouInstances(

   404

                            ComputePouName(words[1]), debug)]

   405

        return []

   406

   407

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

   408

        project = self.GetProject(debug)

   409

        if project is not None:

   410

            return self.InstanceTagnameCollector.Collect(project,

   411

                                                         debug,

   412

                                                         instance_path)

   413

   414

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

   415

        tagname = self.GetPouInstanceTagName(instance_path)

   416

        if tagname is not None:

   417

            infos = self.GetPouVariables(tagname, debug)

   418

            infos.type = tagname

   419

            return infos

   420

        else:

   421

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

   422

            tagname = self.GetPouInstanceTagName(pou_path)

   423

            if tagname is not None:

   424

                pou_infos = self.GetPouVariables(tagname, debug)

   425

                for var_infos in pou_infos.variables:

   426

                    if var_infos.name == var_name:

   427

                        return var_infos

   428

        return None

   429

   430

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

   431

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

   432

        project = self.GetProject(debug)

   433

        if project is not None:

   434

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

   435

        return False

   436

   437

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

   438

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

   439

        project = self.GetProject(debug)

   440

        if project is not None:

   441

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

   442

        return False

   443

   444

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

   445

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

   446

        pou_infos = self.GetPou(reference, debug)

   447

        if pou_infos is not None:

   448

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

   449

        return False

   450

   451

    def GenerateProgram(self, filepath=None):

   452

        errors = []

   453

        warnings = []

   454

        if self.Project is not None:

   455

            try:

   456

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

   457

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

   458

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

   459

                if filepath is not None:

   460

                    programfile = open(filepath, "w")

   461

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

   462

                    programfile.close()

   463

                    self.ProgramFilePath = filepath

   464

                return program_text, errors, warnings

   465

            except PLCGenException as ex:

   466

                errors.append(ex)

   467

        else:

   468

            errors.append("No project opened")

   469

        return "", errors, warnings

   470

   471

    def DebugAvailable(self):

   472

        return self.CurrentCompiledProject is not None

   473

   474

    def ProgramTransferred(self):

   475

        if self.NextCompiledProject is None:

   476

            self.CurrentCompiledProject = self.NextCompiledProject

   477

        else:

   478

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

   479

   480

    def GetChunkInfos(self, from_location, to_location):

   481

        row = self.ProgramOffset + 1

   482

        col = 1

   483

        infos = []

   484

        for chunk, chunk_infos in self.ProgramChunks:

   485

            lines = chunk.split("\n")

   486

            if len(lines) > 1:

   487

                next_row = row + len(lines) - 1

   488

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

   489

            else:

   490

                next_row = row

   491

                next_col = col + len(chunk)

   492

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

   493

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

   494

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

   495

                return infos

   496

            row, col = next_row, next_col

   497

        return infos

   498

   499

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

   500

    #                        Project Pous management functions

   501

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