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

    29

from types import TupleType

    30

from copy import deepcopy

    31

import os

    32

import re

    33

import datetime

    34

from time import localtime

    35

    36

import util.paths as paths

    37

from plcopen import *

    38

from plcopen.types_enums import *

    39

from plcopen.InstancesPathCollector import InstancesPathCollector

    40

from plcopen.POUVariablesCollector import POUVariablesCollector

    41

from plcopen.InstanceTagnameCollector import InstanceTagnameCollector

    42

from plcopen.BlockInstanceCollector import BlockInstanceCollector

    43

from plcopen.VariableInfoCollector import VariableInfoCollector

    44

from graphics.GraphicCommons import *

    45

from PLCGenerator import *

    46

    47

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)?")

    48

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

    49

    50

ScriptDirectory = paths.AbsDir(__file__)

    51

    52

# Length of the buffer

    53

UNDO_BUFFER_LENGTH = 20

    54

    55

    56

class UndoBuffer(object):

    57

    """

    58

    Undo Buffer for PLCOpenEditor

    59

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

    60

    """

    61

    62

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

    63

        """

    64

        Constructor initialising buffer

    65

        """

    66

        self.Buffer = []

    67

        self.CurrentIndex = -1

    68

        self.MinIndex = -1

    69

        self.MaxIndex = -1

    70

        # if current state is defined

    71

        if currentstate:

    72

            self.CurrentIndex = 0

    73

            self.MinIndex = 0

    74

            self.MaxIndex = 0

    75

        # Initialising buffer with currentstate at the first place

    76

        for i in xrange(UNDO_BUFFER_LENGTH):

    77

            if i == 0:

    78

                self.Buffer.append(currentstate)

    79

            else:

    80

                self.Buffer.append(None)

    81

        # Initialising index of state saved

    82

        if issaved:

    83

            self.LastSave = 0

    84

        else:

    85

            self.LastSave = -1

    86

    87

    def Buffering(self, currentstate):

    88

        """

    89

        Add a new state in buffer

    90

        """

    91

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

    92

        self.Buffer[self.CurrentIndex] = currentstate

    93

        # Actualising buffer limits

    94

        self.MaxIndex = self.CurrentIndex

    95

        if self.MinIndex == self.CurrentIndex:

    96

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

    97

            if self.LastSave == self.MinIndex:

    98

                self.LastSave = -1

    99

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

   100

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

   101

   102

    def Current(self):

   103

        """

   104

        Return current state of buffer

   105

        """

   106

        return self.Buffer[self.CurrentIndex]

   107

   108

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

   109

    def Previous(self):

   110

        if self.CurrentIndex != self.MinIndex:

   111

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

   112

            return self.Buffer[self.CurrentIndex]

   113

        return None

   114

   115

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

   116

    def Next(self):

   117

        if self.CurrentIndex != self.MaxIndex:

   118

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

   119

            return self.Buffer[self.CurrentIndex]

   120

        return None

   121

   122

    # Return True if current state is the first in buffer

   123

    def IsFirst(self):

   124

        return self.CurrentIndex == self.MinIndex

   125

   126

    # Return True if current state is the last in buffer

   127

    def IsLast(self):

   128

        return self.CurrentIndex == self.MaxIndex

   129

   130

    # Note that current state is saved

   131

    def CurrentSaved(self):

   132

        self.LastSave = self.CurrentIndex

   133

   134

    # Return True if current state is saved

   135

    def IsCurrentSaved(self):

   136

        return self.LastSave == self.CurrentIndex

   137

   138

   139

class PLCControler(object):

   140

    """

   141

    Controler for PLCOpenEditor

   142

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

   143

    """

   144

   145

    # Create a new PLCControler

   146

    def __init__(self):

   147

        self.LastNewIndex = 0

   148

        self.Reset()

   149

        self.InstancesPathCollector = InstancesPathCollector(self)

   150

        self.POUVariablesCollector = POUVariablesCollector(self)

   151

        self.InstanceTagnameCollector = InstanceTagnameCollector(self)

   152

        self.BlockInstanceCollector = BlockInstanceCollector(self)

   153

        self.VariableInfoCollector = VariableInfoCollector(self)

   154

   155

    # Reset PLCControler internal variables

   156

    def Reset(self):

   157

        self.Project = None

   158

        self.ProjectBufferEnabled = True

   159

        self.ProjectBuffer = None

   160

        self.ProjectSaved = True

   161

        self.Buffering = False

   162

        self.FilePath = ""

   163

        self.FileName = ""

   164

        self.ProgramChunks = []

   165

        self.ProgramOffset = 0

   166

        self.NextCompiledProject = None

   167

        self.CurrentCompiledProject = None

   168

        self.ConfNodeTypes = []

   169

        self.TotalTypesDict = StdBlckDct.copy()

   170

        self.TotalTypes = StdBlckLst[:]

   171

        self.ProgramFilePath = ""

   172

   173

    def GetQualifierTypes(self):

   174

        return QualifierList

   175

   176

    def GetProject(self, debug=False):

   177

        if debug and self.CurrentCompiledProject is not None:

   178

            return self.CurrentCompiledProject

   179

        else:

   180

            return self.Project

   181

   182

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

   183

    #                         Project management functions

   184

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

   185

   186

    # Return if a project is opened

   187

    def HasOpenedProject(self):

   188

        return self.Project is not None

   189

   190

    # Create a new project by replacing the current one

   191

    def CreateNewProject(self, properties):

   192

        # Create the project

   193

        self.Project = PLCOpenParser.CreateRoot()

   194

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

   195

        self.Project.setfileHeader(properties)

   196

        self.Project.setcontentHeader(properties)

   197

        self.SetFilePath("")

   198

   199

        # Initialize the project buffer

   200

        self.CreateProjectBuffer(False)

   201

        self.ProgramChunks = []

   202

        self.ProgramOffset = 0

   203

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

   204

        self.CurrentCompiledProject = None

   205

        self.Buffering = False

   206

   207

    # Return project data type names

   208

    def GetProjectDataTypeNames(self, debug=False):

   209

        project = self.GetProject(debug)

   210

        if project is not None:

   211

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

   212

        return []

   213

   214

    # Return project pou names

   215

    def GetProjectPouNames(self, debug=False):

   216

        project = self.GetProject(debug)

   217

        if project is not None:

   218

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

   219

        return []

   220

   221

    # Return project pou names

   222

    def GetProjectConfigNames(self, debug=False):

   223

        project = self.GetProject(debug)

   224

        if project is not None:

   225

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

   226

        return []

   227

   228

    # Return project pou variable names

   229

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

   230

        variables = []

   231

        project = self.GetProject(debug)

   232

        if project is not None:

   233

            for pou in project.getpous():

   234

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

   235

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

   236

                    for transition in pou.gettransitionList():

   237

                        variables.append(transition.getname())

   238

                    for action in pou.getactionList():

   239

                        variables.append(action.getname())

   240

        return variables

   241

   242

    # Return file path if project is an open file

   243

    def GetFilePath(self):

   244

        return self.FilePath

   245

   246

    # Return file path if project is an open file

   247

    def GetProgramFilePath(self):

   248

        return self.ProgramFilePath

   249

   250

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

   251

    def GetFilename(self):

   252

        if self.Project is not None:

   253

            if self.ProjectIsSaved():

   254

                return self.FileName

   255

            else:

   256

                return "~%s~" % self.FileName

   257

        return ""

   258

   259

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

   260

    def SetFilePath(self, filepath):

   261

        self.FilePath = filepath

   262

        if filepath == "":

   263

            self.LastNewIndex += 1

   264

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

   265

        else:

   266

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

   267

   268

    # Change project properties

   269

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

   270

        if self.Project is not None:

   271

            if name is not None:

   272

                self.Project.setname(name)

   273

            if properties is not None:

   274

                self.Project.setfileHeader(properties)

   275

                self.Project.setcontentHeader(properties)

   276

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

   277

                self.BufferProject()

   278

   279

    # Return project name

   280

    def GetProjectName(self, debug=False):

   281

        project = self.GetProject(debug)

   282

        if project is not None:

   283

            return project.getname()

   284

        return None

   285

   286

    # Return project properties

   287

    def GetProjectProperties(self, debug=False):

   288

        project = self.GetProject(debug)

   289

        if project is not None:

   290

            properties = project.getfileHeader()

   291

            properties.update(project.getcontentHeader())

   292

            return properties

   293

        return None

   294

   295

    # Return project informations

   296

    def GetProjectInfos(self, debug=False):

   297

        project = self.GetProject(debug)

   298

        if project is not None:

   299

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

   300

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

   301

            for datatype in project.getdataTypes():

   302

                datatypes["values"].append({

   303

                    "name": datatype.getname(),

   304

                    "type": ITEM_DATATYPE,

   305

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

   306

                    "values": []})

   307

            pou_types = {

   308

                "function": {

   309

                    "name":   FUNCTIONS,

   310

                    "type":   ITEM_FUNCTION,

   311

                    "values": []

   312

                },

   313

                "functionBlock": {

   314

                    "name":   FUNCTION_BLOCKS,

   315

                    "type":   ITEM_FUNCTIONBLOCK,

   316

                    "values": []

   317

                },

   318

                "program": {

   319

                    "name":   PROGRAMS,

   320

                    "type":   ITEM_PROGRAM,

   321

                    "values": []

   322

                }

   323

            }

   324

            for pou in project.getpous():

   325

                pou_type = pou.getpouType()

   326

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

   327

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

   328

                pou_values = []

   329

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

   330

                    transitions = []

   331

                    for transition in pou.gettransitionList():

   332

                        transitions.append({

   333

                            "name": transition.getname(),

   334

                            "type": ITEM_TRANSITION,

   335

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

   336

                            "values": []})

   337

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

   338

                    actions = []

   339

                    for action in pou.getactionList():

   340

                        actions.append({

   341

                            "name": action.getname(),

   342

                            "type": ITEM_ACTION,

   343

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

   344

                            "values": []})

   345

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

   346

                if pou_type in pou_types:

   347

                    pou_infos["values"] = pou_values

   348

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

   349

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

   350

            for config in project.getconfigurations():

   351

                config_name = config.getname()

   352

                config_infos = {

   353

                    "name": config_name,

   354

                    "type": ITEM_CONFIGURATION,

   355

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

   356

                    "values": []}

   357

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

   358

                for resource in config.getresource():

   359

                    resource_name = resource.getname()

   360

                    resource_infos = {

   361

                        "name": resource_name,

   362

                        "type": ITEM_RESOURCE,

   363

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

   364

                        "values": []}

   365

                    resources["values"].append(resource_infos)

   366

                config_infos["values"] = [resources]

   367

                configurations["values"].append(config_infos)

   368

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

   369

                               pou_types["program"], configurations]

   370

            return infos

   371

        return None

   372

   373

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

   374

        project = self.GetProject(debug)

   375

        if project is not None:

   376

            obj = None

   377

            words = tagname.split("::")

   378

            if words[0] == "P":

   379

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

   380

            elif words[0] != "D":

   381

                obj = self.GetEditedElement(tagname, debug)

   382

            if obj is not None:

   383

                return self.POUVariablesCollector.Collect(obj, debug)

   384

   385

        return None

   386

   387

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

   388

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

   389

   390

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

   391

        project = self.GetProject(debug)

   392

        if project is not None:

   393

            words = tagname.split("::")

   394

            if words[0] == "P":

   395

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

   396

            elif words[0] == 'C':

   397

                return [words[1]]

   398

            elif words[0] == 'R':

   399

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

   400

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

   401

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

   402

                        for instance in self.SearchPouInstances(

   403

                            ComputePouName(words[1]), debug)]

   404

        return []

   405

   406

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

   407

        project = self.GetProject(debug)

   408

        if project is not None:

   409

            return self.InstanceTagnameCollector.Collect(project,

   410

                                                         debug,

   411

                                                         instance_path)

   412

   413

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

   414

        tagname = self.GetPouInstanceTagName(instance_path)

   415

        if tagname is not None:

   416

            infos = self.GetPouVariables(tagname, debug)

   417

            infos.type = tagname

   418

            return infos

   419

        else:

   420

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

   421

            tagname = self.GetPouInstanceTagName(pou_path)

   422

            if tagname is not None:

   423

                pou_infos = self.GetPouVariables(tagname, debug)

   424

                for var_infos in pou_infos.variables:

   425

                    if var_infos.name == var_name:

   426

                        return var_infos

   427

        return None

   428

   429

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

   430

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

   431

        project = self.GetProject(debug)

   432

        if project is not None:

   433

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

   434

        return False

   435

   436

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

   437

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

   438

        project = self.GetProject(debug)

   439

        if project is not None:

   440

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

   441

        return False

   442

   443

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

   444

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

   445

        pou_infos = self.GetPou(reference, debug)

   446

        if pou_infos is not None:

   447

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

   448

        return False

   449

   450

    def GenerateProgram(self, filepath=None):

   451

        errors = []

   452

        warnings = []

   453

        if self.Project is not None:

   454

            try:

   455

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

   456

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

   457

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

   458

                if filepath is not None:

   459

                    programfile = open(filepath, "w")

   460

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

   461

                    programfile.close()

   462

                    self.ProgramFilePath = filepath

   463

                return program_text, errors, warnings

   464

            except PLCGenException as ex:

   465

                errors.append(ex.message)

   466

        else:

   467

            errors.append("No project opened")

   468

        return "", errors, warnings

   469

   470

    def DebugAvailable(self):

   471

        return self.CurrentCompiledProject is not None

   472

   473

    def ProgramTransferred(self):

   474

        if self.NextCompiledProject is None:

   475

            self.CurrentCompiledProject = self.NextCompiledProject

   476

        else:

   477

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

   478

   479

    def GetChunkInfos(self, from_location, to_location):

   480

        row = self.ProgramOffset + 1

   481

        col = 1

   482

        infos = []

   483

        for chunk, chunk_infos in self.ProgramChunks:

   484

            lines = chunk.split("\n")

   485

            if len(lines) > 1:

   486

                next_row = row + len(lines) - 1

   487

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

   488

            else:

   489

                next_row = row

   490

                next_col = col + len(chunk)

   491

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

   492

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

   493

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

   494

                return infos

   495

            row, col = next_row, next_col

   496

        return infos

   497

   498

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

   499

    #                        Project Pous management functions

   500

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

   501

   502