1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library is distributed in the hope that it will be useful,

    17

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

from xml.dom import minidom

    26

from types import StringType, UnicodeType

    27

import cPickle

    28

import os,sys,re

    29

from time import localtime

    30

from datetime import *

    31

    32

from plcopen import plcopen

    33

from plcopen.structures import *

    34

from graphics.GraphicCommons import *

    35

from PLCGenerator import *

    36

    37

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

    38

    39

ITEMS_EDITABLE = [ITEM_PROJECT,

    40

                    ITEM_POU,

    41

                    ITEM_VARIABLE,

    42

                    ITEM_TRANSITION,

    43

                    ITEM_ACTION,

    44

                    ITEM_CONFIGURATION,

    45

                    ITEM_RESOURCE,

    46

                    ITEM_DATATYPE] = range(8)

    47

    48

ITEMS_UNEDITABLE=[ITEM_DATATYPES,

    49

                  ITEM_FUNCTION,

    50

                  ITEM_FUNCTIONBLOCK,

    51

                  ITEM_PROGRAM,

    52

                  ITEM_TRANSITIONS,

    53

                  ITEM_ACTIONS,

    54

                  ITEM_CONFIGURATIONS,

    55

                  ITEM_RESOURCES,

    56

                  ITEM_PROPERTIES,

    57

                  ]=range(9,18)

    58

    59

ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]

    60

    61

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

    62

#                         Undo Buffer for PLCOpenEditor

    63

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

    64

    65

# Length of the buffer

    66

UNDO_BUFFER_LENGTH = 20

    67

    68

"""

    69

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

    70

"""

    71

class UndoBuffer:

    72

    73

    # Constructor initialising buffer

    74

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

    75

        self.Buffer = []

    76

        self.CurrentIndex = -1

    77

        self.MinIndex = -1

    78

        self.MaxIndex = -1

    79

        # if current state is defined

    80

        if currentstate:

    81

            self.CurrentIndex = 0

    82

            self.MinIndex = 0

    83

            self.MaxIndex = 0

    84

        # Initialising buffer with currentstate at the first place

    85

        for i in xrange(UNDO_BUFFER_LENGTH):

    86

            if i == 0:

    87

                self.Buffer.append(currentstate)

    88

            else:

    89

                self.Buffer.append(None)

    90

        # Initialising index of state saved

    91

        if issaved:

    92

            self.LastSave = 0

    93

        else:

    94

            self.LastSave = -1

    95

    96

    # Add a new state in buffer

    97

    def Buffering(self, currentstate):

    98

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

    99

        self.Buffer[self.CurrentIndex] = currentstate

   100

        # Actualising buffer limits

   101

        self.MaxIndex = self.CurrentIndex

   102

        if self.MinIndex == self.CurrentIndex:

   103

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

   104

            if self.LastSave == self.MinIndex:

   105

                self.LastSave = -1

   106

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

   107

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

   108

   109

    # Return current state of buffer

   110

    def Current(self):

   111

        return self.Buffer[self.CurrentIndex]

   112

   113

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

   114

    def Previous(self):

   115

        if self.CurrentIndex != self.MinIndex:

   116

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

   117

            return self.Buffer[self.CurrentIndex]

   118

        return None

   119

   120

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

   121

    def Next(self):

   122

        if self.CurrentIndex != self.MaxIndex:

   123

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

   124

            return self.Buffer[self.CurrentIndex]

   125

        return None

   126

   127

    # Return True if current state is the first in buffer

   128

    def IsFirst(self):

   129

        return self.CurrentIndex == self.MinIndex

   130

   131

    # Return True if current state is the last in buffer

   132

    def IsLast(self):

   133

        return self.CurrentIndex == self.MaxIndex

   134

   135

    # Note that current state is saved

   136

    def CurrentSaved(self):

   137

        self.LastSave = self.CurrentIndex

   138

   139

    # Return True if current state is saved

   140

    def IsCurrentSaved(self):

   141

        return self.LastSave == self.CurrentIndex

   142

   143

   144

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

   145

#                           Controler for PLCOpenEditor

   146

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

   147

   148

"""

   149

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

   150

"""

   151

class PLCControler:

   152

   153

    # Create a new PLCControler

   154

    def __init__(self):

   155

        self.LastNewIndex = 0

   156

        self.Reset()

   157

   158

    # Reset PLCControler internal variables

   159

    def Reset(self):

   160

        self.Project = None

   161

        self.ProjectBuffer = None

   162

        self.Buffering = False

   163

        self.FilePath = ""

   164

        self.FileName = ""

   165

        self.ProgramFilePath = ""

   166

        self.RefreshDataTypeUsingTree()

   167

        self.RefreshDataTypes()

   168

        self.RefreshPouUsingTree()

   169

        self.RefreshBlockTypes()

   170

   171

    def GetQualifierTypes(self):

   172

        return plcopen.QualifierList

   173

   174

   175

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

   176

#                         Project management functions

   177

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

   178

   179

    # Return if a project is opened

   180

    def HasOpenedProject(self):

   181

        return self.Project != None

   182

   183

    # Create a new project by replacing the current one

   184

    def CreateNewProject(self, properties):

   185

        # Create the project

   186

        self.Project = plcopen.project()

   187

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

   188

        self.Project.setfileHeader(properties)

   189

        self.Project.setcontentHeader(properties)

   190

        self.SetFilePath("")

   191

        # Initialize the project buffer

   192

        self.ProjectBuffer = UndoBuffer(self.Copy(self.Project), False)

   193

        self.Buffering = False

   194

   195

    # Return project data type names

   196

    def GetProjectDataTypeNames(self):

   197

        if self.Project:

   198

            return [datatype.getname() for datatype in self.Project.getdataTypes()]

   199

        return []

   200

   201

    # Return project pou names

   202

    def GetProjectPouNames(self):

   203

        if self.Project:

   204

            return [pou.getname() for pou in self.Project.getpous()]

   205

        return []

   206

   207

    # Return project pou names

   208

    def GetProjectConfigNames(self):

   209

        if self.Project:

   210

            return [config.getName() for config in self.Project.getconfigurations()]

   211

        return []

   212

   213

    # Return project pou variables

   214

    def GetProjectPouVariables(self, pou_name=None):

   215

        variables = []

   216

        for pou in self.Project.getpous():

   217

            if not pou_name or pou_name == pou.getname():

   218

                variables.extend([var["Name"] for var in self.GetPouInterfaceVars(pou)])

   219

                for transition in pou.gettransitionList():

   220

                    variables.append(transition.getname())

   221

                for action in pou.getactionList():

   222

                    variables.append(action.getname())

   223

        return variables

   224

   225

    # Return if project is saved

   226

    def ProjectIsSaved(self):

   227

        return self.ProjectBuffer.IsCurrentSaved()

   228

   229

    # Return file path if project is an open file

   230

    def GetFilePath(self):

   231

        return self.FilePath

   232

   233

    # Return file path if project is an open file

   234

    def GetProgramFilePath(self):

   235

        return self.ProgramFilePath

   236

   237

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

   238

    def GetFilename(self):

   239

        if self.ProjectBuffer.IsCurrentSaved():

   240

            return self.FileName

   241

        else:

   242

            return "~%s~"%self.FileName

   243

   244

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

   245

    def SetFilePath(self, filepath):

   246

        self.FilePath = filepath

   247

        if filepath == "":

   248

            self.LastNewIndex += 1

   249

            self.FileName = "Unnamed%d"%self.LastNewIndex

   250

        else:

   251

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

   252

   253

    # Change project properties

   254

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

   255

        if name != None:

   256

            self.Project.setname(name)

   257

        if properties != None:

   258

            self.Project.setfileHeader(properties)

   259

            self.Project.setcontentHeader(properties)

   260

        if name != None or properties != None:

   261

            self.BufferProject()

   262

   263

    # Return project properties

   264

    def GetProjectProperties(self):

   265

        properties = self.Project.getfileHeader()

   266

        properties.update(self.Project.getcontentHeader())

   267

        return properties

   268

   269

    # Return project informations

   270

    def GetProjectInfos(self):

   271

        if self.Project:

   272

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

   273

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

   274

            for datatype in self.Project.getdataTypes():

   275

                datatypes["values"].append({"name": datatype.getname(), "type": ITEM_DATATYPE, "values": []})

   276

            pou_types = {"function": {"name": "Functions", "type": ITEM_FUNCTION, "values":[]},

   277

                         "functionBlock": {"name": "Function Blocks", "type": ITEM_FUNCTIONBLOCK, "values":[]},

   278

                         "program": {"name": "Programs", "type": ITEM_PROGRAM, "values":[]}}

   279

            for pou in self.Project.getpous():

   280

                pou_type = pou.getpouType()

   281

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

   282

                pou_values = []

   283

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

   284

                    transitions = []

   285

                    for transition in pou.gettransitionList():

   286

                        transitions.append({"name": transition.getname(), "type": ITEM_TRANSITION, "values": []})

   287

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

   288

                    actions = []

   289

                    for action in pou.getactionList():

   290

                        actions.append({"name": action.getname(), "type": ITEM_ACTION, "values": []})

   291

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

   292

                if pou_type in pou_types:

   293

                    pou_infos["values"] = pou_values

   294

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

   295

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

   296

            for config in self.Project.getconfigurations():

   297

                config_name = config.getname()

   298

                config_infos = {"name": config_name, "type": ITEM_CONFIGURATION, "values": []}

   299

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

   300

                for resource in config.getresource():

   301

                    resource_name = resource.getname()

   302

                    resource_infos = {"name": resource_name, "type": ITEM_RESOURCE, "values": []}

   303

                    resources["values"].append(resource_infos)

   304

                config_infos["values"] = [resources]

   305

                configurations["values"].append(config_infos)

   306

            infos["values"] = [{"name": "Properties", "type": ITEM_PROPERTIES, "values": []},

   307

                               datatypes, pou_types["function"], pou_types["functionBlock"], 

   308

                               pou_types["program"], configurations]

   309

            return infos

   310

        return None

   311

   312

    # Return project topology informations

   313

    def GetProjectTopology(self):

   314

        if self.Project:

   315

            infos = {"name": self.Project.getname(), "type": ITEM_PROJECT, "values" : []}

   316

            for config in self.Project.getconfigurations():

   317

                config_infos = {"name" : config.getname(), "type": ITEM_CONFIGURATION, "values" : []}

   318

                for resource in config.getresource():

   319

                    resource_infos = {"name" : resource.getname(), "type": ITEM_RESOURCE, "values": []}

   320

                    for task in resource.gettask():

   321

                        for pou in task.getpouInstance():

   322

                            instance_infos = self.GetPouTopology(pou.getname(), pou.gettype())

   323

                            if instance_infos is not None:

   324

                                resource_infos["values"].append(instance_infos)

   325

                    for pou in resource.getpouInstance():

   326

                        instance_infos = self.GetPouTopology(pou.getname(), pou.gettype())

   327

                        if instance_infos is not None:

   328

                            resource_infos["values"].append(instance_infos)

   329

                    for varlist in resource.getglobalVars():

   330

                        for variable in varlist.getvariable():

   331

                            vartype_content = variable.gettype().getcontent()

   332

                            if vartype_content["name"] == "derived":

   333

                                var_infos = self.GetPouTopology(variable.getname(), vartype_content["value"].getname())

   334

                                if var_infos is not None:

   335

                                    resource_infos["values"].append(var_infos)

   336

                            elif vartype_content["name"] in ["string", "wstring"]:

   337

                                resource_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"].upper()), 

   338

                                                                 "type" : ITEM_VARIABLE, "values" : []})

   339

                            else:

   340

                                resource_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"]), 

   341

                                                                 "type" : ITEM_VARIABLE, "values" : []})

   342

                    config_infos["values"].append(resource_infos)

   343

                for varlist in config.getglobalVars():

   344

                    for variable in varlist.getvariable():

   345

                        vartype_content = variable.gettype().getcontent()

   346

                        if vartype_content["name"] == "derived":

   347

                            var_infos = self.GetPouTopology(variable.getname(), vartype_content["value"].getname())

   348

                            if var_infos is not None:

   349

                                config_infos["values"].append(var_infos)

   350

                        elif vartype_content["name"] in ["string", "wstring"]:

   351

                            config_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"].upper()), 

   352

                                                           "type" : ITEM_VARIABLE, "values" : []})

   353

                        else:

   354

                            config_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"]), 

   355

                                                           "type" : ITEM_VARIABLE, "values" : []})

   356

                infos["values"].append(config_infos)

   357

            return infos

   358

        return None

   359

   360

    # Return pou topology informations

   361

    def GetPouTopology(self, name, type):

   362

        if self.Project:

   363

            pou = self.Project.getpou(type)

   364

            if pou is not None:

   365

                pou_infos = {"name" : "%s(%s)"%(name, type), "type" : ITEM_POU, "values" : []}

   366

                if pou.interface:

   367

                    # Extract variables from every varLists

   368

                    for type, varlist in pou.getvars():

   369

                        for variable in varlist.getvariable():

   370

                            vartype_content = variable.gettype().getcontent()

   371

                            if vartype_content["name"] == "derived":

   372

                                var_infos = self.GetPouTopology(variable.getname(), vartype_content["value"].getname())

   373

                                if var_infos is not None:

   374

                                    pou_infos["values"].append(var_infos)

   375

                            elif vartype_content["name"] in ["string", "wstring"]:

   376

                                pou_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"].upper()), 

   377

                                                               "type" : ITEM_VARIABLE, "values" : []})

   378

                            else:

   379

                                pou_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"]), 

   380

                                                               "type" : ITEM_VARIABLE, "values" : []})

   381

                return pou_infos

   382

            block_infos = GetBlockType(type)

   383

            if block_infos is not None and block_infos["type"] != "function":

   384

                pou_infos = {"name" : "%s(%s)"%(name, type), "type" : ITEM_POU, "values" : []}

   385

                for varname, vartype, varmodifier in block_infos["inputs"]:

   386

                    pou_infos["values"].append({"name" : "%s(%s)"%(varname, vartype), "type" : ITEM_VARIABLE, "values" : []})

   387

                for varname, vartype, varmodifier in block_infos["outputs"]:

   388

                    pou_infos["values"].append({"name" : "%s(%s)"%(varname, vartype), "type" : ITEM_VARIABLE, "values" : []})

   389

                return pou_infos

   390

   391

            if type in TypeHierarchy:

   392

                return {"name" : "%s(%s)"%(name, type), "type" : ITEM_VARIABLE, "values" : []}

   393

   394

        return None

   395

   396

    # Refresh the tree of user-defined data type cross-use

   397

    def RefreshDataTypeUsingTree(self):

   398

        # Reset the tree of user-defined pou cross-use

   399

        self.DataTypeUsingTree = {}

   400

        if self.Project:

   401

            datatypes = self.Project.getdataTypes()

   402

            # Reference all the user-defined data type names and initialize the tree of 

   403

            # user-defined data type cross-use

   404

            datatypenames = [datatype.getname() for datatype in datatypes]

   405

            for name in datatypenames:

   406

                self.DataTypeUsingTree[name] = []

   407

            # Analyze each data type

   408

            for datatype in datatypes:

   409

                name = datatype.getname()

   410

                basetype_content = datatype.getbaseType().getcontent()

   411

                if basetype_content["name"] == "derived":

   412

                    basetype_name = basetype_content["value"].getname()

   413

                    if basetype_name in datatypenames and name not in self.DataTypeUsingTree[basetype_name]:

   414

                        self.DataTypeUsingTree[basetype_name].append(name)

   415

                elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned", "array"]:

   416

                    base_type = basetype_content["value"].baseType.getcontent()

   417

                    if base_type["value"] is not None:

   418

                        basetype_name = base_type["value"].getname()

   419

                        if basetype_name in datatypenames and name not in self.DataTypeUsingTree[basetype_name]:

   420

                            self.DataTypeUsingTree[basetype_name].append(name)

   421

   422

    # Refresh the tree of user-defined pou cross-use

   423

    def RefreshPouUsingTree(self):

   424

        # Reset the tree of user-defined pou cross-use

   425

        self.PouUsingTree = {}

   426

        if self.Project:

   427

            pous = self.Project.getpous()

   428

            # Reference all the user-defined pou names and initialize the tree of 

   429

            # user-defined pou cross-use

   430

            pounames = [pou.getname() for pou in pous]

   431

            for name in pounames:

   432

                self.PouUsingTree[name] = []

   433

            # Analyze each pou 

   434

            for pou in pous:

   435

                name = pou.getname()

   436

                if pou.interface:

   437

                    # Extract variables from every varLists

   438

                    for type, varlist in pou.getvars():

   439

                        for var in varlist.getvariable():

   440

                            vartype_content = var.gettype().getcontent()

   441

                            if vartype_content["name"] == "derived":

   442

                                typename = vartype_content["value"].getname()

   443

                                if typename in pounames and name not in self.PouUsingTree[typename]:

   444

                                    self.PouUsingTree[typename].append(name)

   445

                bodytype = pou.getbodyType()

   446

                # If pou is written in a graphical language

   447

                if bodytype in ["FBD","LD","SFC"]:

   448

                    # Analyze each instance of the pou

   449

                    for instance in pou.getinstances():

   450

                        if isinstance(instance, plcopen.fbdObjects_block):

   451

                            typename = instance.gettypeName()

   452

                            # Update tree if there is a cross-use

   453

                            if typename in pounames and name not in self.PouUsingTree[typename]:

   454

                                 self.PouUsingTree[typename].append(name)

   455

                # If pou is written in a textual language

   456

                elif bodytype in ["IL", "ST"]:

   457

                    text = pou.gettext()

   458

                    # Search if each pou is mentioned in the pou text

   459

                    for typename in pounames:

   460

                        typename_model = re.compile("[ \t\n]%s[ \t\n]"%typename)

   461

                        # Update tree if there is a cross-use

   462

                        if typename != name and typename_model.search(text):

   463

                            self.PouUsingTree[typename].append(name)

   464

   465

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

   466

    def DataTypeIsUsed(self, name):

   467

        if name in self.DataTypeUsingTree:

   468

            return len(self.DataTypeUsingTree[name]) > 0

   469

        return False

   470

   471

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

   472

    def PouIsUsed(self, name):

   473

        if name in self.PouUsingTree:

   474

            return len(self.PouUsingTree[name]) > 0

   475

        return False

   476

   477

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

   478

    def DataTypeIsUsedBy(self, name, reference):

   479

        if name in self.DataTypeUsingTree:

   480

            list = self.DataTypeUsingTree[name]

   481

            # Test if data type is directly used by reference

   482

            if reference in list:

   483

                return True

   484

            else:

   485

                # Test if data type is undirectly used by reference, by testing if data types 

   486

                # that directly use data type is directly or undirectly used by reference

   487

                used = False

   488

                for element in list:

   489

                    used |= self.DataTypeIsUsedBy(element, reference)

   490

                return used

   491

        return False

   492

   493

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

   494

    def PouIsUsedBy(self, name, reference):

   495

        if name in self.PouUsingTree:

   496

            list = self.PouUsingTree[name]

   497

            # Test if pou is directly used by reference

   498

            if reference in list:

   499

                return True

   500

            else:

   501

                # Test if pou is undirectly used by reference, by testing if pous 

   502

                # that directly use pou is directly or undirectly used by reference

   503

                used = False

   504

                for element in list: