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

    48

ScriptDirectory = paths.AbsDir(__file__)

    49

    50

# Length of the buffer

    51

UNDO_BUFFER_LENGTH = 20

    52

    53

    54

class UndoBuffer(object):

    55

    """

    56

    Undo Buffer for PLCOpenEditor

    57

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

    58

    """

    59

    60

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

    61

        """

    62

        Constructor initialising buffer

    63

        """

    64

        self.Buffer = []

    65

        self.CurrentIndex = -1

    66

        self.MinIndex = -1

    67

        self.MaxIndex = -1

    68

        # if current state is defined

    69

        if currentstate:

    70

            self.CurrentIndex = 0

    71

            self.MinIndex = 0

    72

            self.MaxIndex = 0

    73

        # Initialising buffer with currentstate at the first place

    74

        for i in xrange(UNDO_BUFFER_LENGTH):

    75

            if i == 0:

    76

                self.Buffer.append(currentstate)

    77

            else:

    78

                self.Buffer.append(None)

    79

        # Initialising index of state saved

    80

        if issaved:

    81

            self.LastSave = 0

    82

        else:

    83

            self.LastSave = -1

    84

    85

    def Buffering(self, currentstate):

    86

        """

    87

        Add a new state in buffer

    88

        """

    89

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

    90

        self.Buffer[self.CurrentIndex] = currentstate

    91

        # Actualising buffer limits

    92

        self.MaxIndex = self.CurrentIndex

    93

        if self.MinIndex == self.CurrentIndex:

    94

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

    95

            if self.LastSave == self.MinIndex:

    96

                self.LastSave = -1

    97

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

    98

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

    99

   100

    def Current(self):

   101

        """

   102

        Return current state of buffer

   103

        """

   104

        return self.Buffer[self.CurrentIndex]

   105

   106

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

   107

    def Previous(self):

   108

        if self.CurrentIndex != self.MinIndex:

   109

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

   110

            return self.Buffer[self.CurrentIndex]

   111

        return None

   112

   113

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

   114

    def Next(self):

   115

        if self.CurrentIndex != self.MaxIndex:

   116

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

   117

            return self.Buffer[self.CurrentIndex]

   118

        return None

   119

   120

    # Return True if current state is the first in buffer

   121

    def IsFirst(self):

   122

        return self.CurrentIndex == self.MinIndex

   123

   124

    # Return True if current state is the last in buffer

   125

    def IsLast(self):

   126

        return self.CurrentIndex == self.MaxIndex

   127

   128

    # Note that current state is saved

   129

    def CurrentSaved(self):

   130

        self.LastSave = self.CurrentIndex

   131

   132

    # Return True if current state is saved

   133

    def IsCurrentSaved(self):

   134

        return self.LastSave == self.CurrentIndex

   135

   136

   137

class PLCControler(object):

   138

    """

   139

    Controler for PLCOpenEditor

   140

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

   141

    """

   142

   143

    # Create a new PLCControler

   144

    def __init__(self):

   145

        self.LastNewIndex = 0

   146

        self.Reset()

   147

        self.InstancesPathCollector = InstancesPathCollector(self)

   148

        self.POUVariablesCollector = POUVariablesCollector(self)

   149

        self.InstanceTagnameCollector = InstanceTagnameCollector(self)

   150

        self.BlockInstanceCollector = BlockInstanceCollector(self)

   151

        self.VariableInfoCollector = VariableInfoCollector(self)

   152

   153

    # Reset PLCControler internal variables

   154

    def Reset(self):

   155

        self.Project = None

   156

        self.ProjectBufferEnabled = True

   157

        self.ProjectBuffer = None

   158

        self.ProjectSaved = True

   159

        self.Buffering = False

   160

        self.FilePath = ""

   161

        self.FileName = ""

   162

        self.ProgramChunks = []

   163

        self.ProgramOffset = 0

   164

        self.NextCompiledProject = None

   165

        self.CurrentCompiledProject = None

   166

        self.ConfNodeTypes = []

   167

        self.TotalTypesDict = StdBlckDct.copy()

   168

        self.TotalTypes = StdBlckLst[:]

   169

        self.ProgramFilePath = ""

   170

   171

    def GetQualifierTypes(self):

   172

        return QualifierList

   173

   174

    def GetProject(self, debug=False):

   175

        if debug and self.CurrentCompiledProject is not None:

   176

            return self.CurrentCompiledProject

   177

        else:

   178

            return self.Project

   179

   180

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

   181

    #                         Project management functions

   182

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

   183

   184

    # Return if a project is opened

   185

    def HasOpenedProject(self):

   186

        return self.Project is not None

   187

   188

    # Create a new project by replacing the current one

   189

    def CreateNewProject(self, properties):

   190

        # Create the project

   191

        self.Project = PLCOpenParser.CreateRoot()

   192

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

   193

        self.Project.setfileHeader(properties)

   194

        self.Project.setcontentHeader(properties)

   195

        self.SetFilePath("")

   196

   197

        # Initialize the project buffer

   198

        self.CreateProjectBuffer(False)

   199

        self.ProgramChunks = []

   200

        self.ProgramOffset = 0

   201

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

   202

        self.CurrentCompiledProject = None

   203

        self.Buffering = False

   204

   205

    # Return project data type names

   206

    def GetProjectDataTypeNames(self, debug=False):

   207

        project = self.GetProject(debug)

   208

        if project is not None:

   209

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

   210

        return []

   211

   212

    # Return project pou names

   213

    def GetProjectPouNames(self, debug=False):

   214

        project = self.GetProject(debug)

   215

        if project is not None:

   216

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

   217

        return []

   218

   219

    # Return project pou names

   220

    def GetProjectConfigNames(self, debug=False):

   221

        project = self.GetProject(debug)

   222

        if project is not None:

   223

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

   224

        return []

   225

   226

    # Return project pou variable names

   227

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

   228

        variables = []

   229

        project = self.GetProject(debug)

   230

        if project is not None:

   231

            for pou in project.getpous():

   232

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

   233

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

   234

                    for transition in pou.gettransitionList():

   235

                        variables.append(transition.getname())

   236

                    for action in pou.getactionList():

   237

                        variables.append(action.getname())

   238

        return variables

   239

   240

    # Return file path if project is an open file

   241

    def GetFilePath(self):

   242

        return self.FilePath

   243

   244

    # Return file path if project is an open file

   245

    def GetProgramFilePath(self):

   246

        return self.ProgramFilePath

   247

   248

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

   249

    def GetFilename(self):

   250

        if self.Project is not None:

   251

            if self.ProjectIsSaved():

   252

                return self.FileName

   253

            else:

   254

                return "~%s~" % self.FileName

   255

        return ""

   256

   257

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

   258

    def SetFilePath(self, filepath):

   259

        self.FilePath = filepath

   260

        if filepath == "":

   261

            self.LastNewIndex += 1

   262

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

   263

        else:

   264

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

   265

   266

    # Change project properties

   267

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

   268

        if self.Project is not None:

   269

            if name is not None:

   270

                self.Project.setname(name)

   271

            if properties is not None:

   272

                self.Project.setfileHeader(properties)

   273

                self.Project.setcontentHeader(properties)

   274

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

   275

                self.BufferProject()

   276

   277

    # Return project name

   278

    def GetProjectName(self, debug=False):

   279

        project = self.GetProject(debug)

   280

        if project is not None:

   281

            return project.getname()

   282

        return None

   283

   284

    # Return project properties

   285

    def GetProjectProperties(self, debug=False):

   286

        project = self.GetProject(debug)

   287

        if project is not None:

   288

            properties = project.getfileHeader()

   289

            properties.update(project.getcontentHeader())

   290

            return properties

   291

        return None

   292

   293

    # Return project informations

   294

    def GetProjectInfos(self, debug=False):

   295

        project = self.GetProject(debug)

   296

        if project is not None:

   297

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

   298

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

   299

            for datatype in project.getdataTypes():

   300

                datatypes["values"].append({

   301

                    "name": datatype.getname(),

   302

                    "type": ITEM_DATATYPE,

   303

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

   304

                    "values": []})

   305

            pou_types = {

   306

                "function": {

   307

                    "name":   FUNCTIONS,

   308

                    "type":   ITEM_FUNCTION,

   309

                    "values": []

   310

                },

   311

                "functionBlock": {

   312

                    "name":   FUNCTION_BLOCKS,

   313

                    "type":   ITEM_FUNCTIONBLOCK,

   314

                    "values": []

   315

                },

   316

                "program": {

   317

                    "name":   PROGRAMS,

   318

                    "type":   ITEM_PROGRAM,

   319

                    "values": []

   320

                }

   321

            }

   322

            for pou in project.getpous():

   323

                pou_type = pou.getpouType()

   324

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

   325

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

   326

                pou_values = []

   327

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

   328

                    transitions = []

   329

                    for transition in pou.gettransitionList():

   330

                        transitions.append({

   331

                            "name": transition.getname(),

   332

                            "type": ITEM_TRANSITION,

   333

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

   334

                            "values": []})

   335

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

   336

                    actions = []

   337

                    for action in pou.getactionList():

   338

                        actions.append({

   339

                            "name": action.getname(),

   340

                            "type": ITEM_ACTION,

   341

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

   342

                            "values": []})

   343

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

   344

                if pou_type in pou_types:

   345

                    pou_infos["values"] = pou_values

   346

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

   347

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

   348

            for config in project.getconfigurations():

   349

                config_name = config.getname()

   350

                config_infos = {

   351

                    "name": config_name,

   352

                    "type": ITEM_CONFIGURATION,

   353

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

   354

                    "values": []}

   355

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

   356

                for resource in config.getresource():

   357

                    resource_name = resource.getname()

   358

                    resource_infos = {

   359

                        "name": resource_name,

   360

                        "type": ITEM_RESOURCE,

   361

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

   362

                        "values": []}

   363

                    resources["values"].append(resource_infos)

   364

                config_infos["values"] = [resources]

   365

                configurations["values"].append(config_infos)

   366

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

   367

                               pou_types["program"], configurations]

   368

            return infos

   369

        return None

   370

   371

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

   372

        project = self.GetProject(debug)

   373

        if project is not None:

   374

            obj = None

   375

            words = tagname.split("::")

   376

            if words[0] == "P":

   377

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

   378

            elif words[0] != "D":

   379

                obj = self.GetEditedElement(tagname, debug)

   380

            if obj is not None:

   381

                return self.POUVariablesCollector.Collect(obj, debug)

   382

   383

        return None

   384

   385

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

   386

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

   387

   388

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

   389

        project = self.GetProject(debug)

   390

        if project is not None:

   391

            words = tagname.split("::")

   392

            if words[0] == "P":

   393

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

   394

            elif words[0] == 'C':

   395

                return [words[1]]

   396

            elif words[0] == 'R':

   397

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

   398

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

   399

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

   400

                        for instance in self.SearchPouInstances(

   401

                            ComputePouName(words[1]), debug)]

   402

        return []

   403

   404

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

   405

        project = self.GetProject(debug)

   406

        if project is not None:

   407

            return self.InstanceTagnameCollector.Collect(project,

   408

                                                         debug,

   409

                                                         instance_path)

   410

   411

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

   412

        tagname = self.GetPouInstanceTagName(instance_path)

   413

        if tagname is not None:

   414

            infos = self.GetPouVariables(tagname, debug)

   415

            infos.type = tagname

   416

            return infos

   417

        else:

   418

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

   419

            tagname = self.GetPouInstanceTagName(pou_path)

   420

            if tagname is not None:

   421

                pou_infos = self.GetPouVariables(tagname, debug)

   422

                for var_infos in pou_infos.variables:

   423

                    if var_infos.name == var_name:

   424

                        return var_infos

   425

        return None

   426

   427

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

   428

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

   429

        project = self.GetProject(debug)

   430

        if project is not None:

   431

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

   432

        return False

   433

   434

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

   435

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

   436

        project = self.GetProject(debug)

   437

        if project is not None:

   438

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

   439

        return False

   440

   441

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

   442

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

   443

        pou_infos = self.GetPou(reference, debug)

   444

        if pou_infos is not None:

   445

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

   446

        return False

   447

   448

    def GenerateProgram(self, filepath=None):

   449

        errors = []

   450

        warnings = []

   451

        if self.Project is not None:

   452

            try:

   453

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

   454

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

   455

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

   456

                if filepath is not None:

   457

                    programfile = open(filepath, "w")

   458

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

   459

                    programfile.close()

   460

                    self.ProgramFilePath = filepath

   461

                return program_text, errors, warnings

   462

            except PLCGenException, ex:

   463

                errors.append(ex.message)

   464

        else:

   465

            errors.append("No project opened")

   466

        return "", errors, warnings

   467

   468

    def DebugAvailable(self):

   469

        return self.CurrentCompiledProject is not None

   470

   471

    def ProgramTransferred(self):

   472

        if self.NextCompiledProject is None:

   473

            self.CurrentCompiledProject = self.NextCompiledProject

   474

        else:

   475

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

   476

   477

    def GetChunkInfos(self, from_location, to_location):

   478

        row = self.ProgramOffset + 1

   479

        col = 1

   480

        infos = []

   481

        for chunk, chunk_infos in self.ProgramChunks:

   482

            lines = chunk.split("\n")

   483

            if len(lines) > 1:

   484

                next_row = row + len(lines) - 1

   485

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

   486

            else:

   487

                next_row = row

   488

                next_col = col + len(chunk)

   489

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

   490

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

   491

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

   492

                return infos

   493

            row, col = next_row, next_col

   494

        return infos

   495

   496

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

   497

    #                        Project Pous management functions

   498

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

   499

   500

    # Add a Data Type to Project

   501

    def ProjectAddDataType(self, datatype_name=None):

   502

        if self.Project is not None: