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

    47

                 ] = range(8)

    48

    49

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    50

                    ITEM_FUNCTION,

    51

                    ITEM_FUNCTIONBLOCK,

    52

                    ITEM_PROGRAM,

    53

                    ITEM_TRANSITIONS,

    54

                    ITEM_ACTIONS,

    55

                    ITEM_CONFIGURATIONS,

    56

                    ITEM_RESOURCES,

    57

                    ITEM_PROPERTIES

    58

                   ] = range(8, 17)

    59

    60

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    61

                  ITEM_VAR_GLOBAL,

    62

                  ITEM_VAR_EXTERNAL,

    63

                  ITEM_VAR_TEMP,

    64

                  ITEM_VAR_INPUT,

    65

                  ITEM_VAR_OUTPUT,

    66

                  ITEM_VAR_INOUT

    67

                 ] = range(17, 24)

    68

    69

VAR_CLASS_INFOS = {"Local" :    (plcopen.interface_localVars,    ITEM_VAR_LOCAL),

    70

                   "Global" :   (plcopen.interface_globalVars,   ITEM_VAR_GLOBAL),

    71

                   "External" : (plcopen.interface_externalVars, ITEM_VAR_EXTERNAL),

    72

                   "Temp" :     (plcopen.interface_tempVars,     ITEM_VAR_TEMP),

    73

                   "Input" :    (plcopen.interface_inputVars,    ITEM_VAR_INPUT),

    74

                   "Output" :   (plcopen.interface_outputVars,   ITEM_VAR_OUTPUT),

    75

                   "InOut" :    (plcopen.interface_inOutVars,    ITEM_VAR_INOUT)

    76

                  }

    77

    78

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

    79

    80

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

    81

#                         Undo Buffer for PLCOpenEditor

    82

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

    83

    84

# Length of the buffer

    85

UNDO_BUFFER_LENGTH = 20

    86

    87

"""

    88

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

    89

"""

    90

class UndoBuffer:

    91

    92

    # Constructor initialising buffer

    93

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

    94

        self.Buffer = []

    95

        self.CurrentIndex = -1

    96

        self.MinIndex = -1

    97

        self.MaxIndex = -1

    98

        # if current state is defined

    99

        if currentstate:

   100

            self.CurrentIndex = 0

   101

            self.MinIndex = 0

   102

            self.MaxIndex = 0

   103

        # Initialising buffer with currentstate at the first place

   104

        for i in xrange(UNDO_BUFFER_LENGTH):

   105

            if i == 0:

   106

                self.Buffer.append(currentstate)

   107

            else:

   108

                self.Buffer.append(None)

   109

        # Initialising index of state saved

   110

        if issaved:

   111

            self.LastSave = 0

   112

        else:

   113

            self.LastSave = -1

   114

   115

    # Add a new state in buffer

   116

    def Buffering(self, currentstate):

   117

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

   118

        self.Buffer[self.CurrentIndex] = currentstate

   119

        # Actualising buffer limits

   120

        self.MaxIndex = self.CurrentIndex

   121

        if self.MinIndex == self.CurrentIndex:

   122

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

   123

            if self.LastSave == self.MinIndex:

   124

                self.LastSave = -1

   125

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

   126

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

   127

   128

    # Return current state of buffer

   129

    def Current(self):

   130

        return self.Buffer[self.CurrentIndex]

   131

   132

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

   133

    def Previous(self):

   134

        if self.CurrentIndex != self.MinIndex:

   135

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

   136

            return self.Buffer[self.CurrentIndex]

   137

        return None

   138

   139

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

   140

    def Next(self):

   141

        if self.CurrentIndex != self.MaxIndex:

   142

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

   143

            return self.Buffer[self.CurrentIndex]

   144

        return None

   145

   146

    # Return True if current state is the first in buffer

   147

    def IsFirst(self):

   148

        return self.CurrentIndex == self.MinIndex

   149

   150

    # Return True if current state is the last in buffer

   151

    def IsLast(self):

   152

        return self.CurrentIndex == self.MaxIndex

   153

   154

    # Note that current state is saved

   155

    def CurrentSaved(self):

   156

        self.LastSave = self.CurrentIndex

   157

   158

    # Return True if current state is saved

   159

    def IsCurrentSaved(self):

   160

        return self.LastSave == self.CurrentIndex

   161

   162

   163

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

   164

#                           Controler for PLCOpenEditor

   165

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

   166

   167

"""

   168

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

   169

"""

   170

class PLCControler:

   171

   172

    # Create a new PLCControler

   173

    def __init__(self):

   174

        self.LastNewIndex = 0

   175

        self.Reset()

   176

   177

    # Reset PLCControler internal variables

   178

    def Reset(self):

   179

        self.Project = None

   180

        self.ProjectBufferEnabled = False

   181

        self.ProjectBuffer = None

   182

        self.ProjectSaved = False

   183

        self.Buffering = False

   184

        self.FilePath = ""

   185

        self.FileName = ""

   186

        self.ProgramChunks = []

   187

        self.NextCompiledProject = None

   188

        self.CurrentCompiledProject = None

   189

        self.PluginTypes = []

   190

        self.ProgramFilePath = ""

   191

   192

    def GetQualifierTypes(self):

   193

        return plcopen.QualifierList

   194

   195

    def GetProject(self, debug = False):

   196

        if debug and self.CurrentCompiledProject is not None:

   197

            return self.CurrentCompiledProject

   198

        else:

   199

            return self.Project

   200

   201

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

   202

#                         Project management functions

   203

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

   204

   205

    # Return if a project is opened

   206

    def HasOpenedProject(self):

   207

        return self.Project is not None

   208

   209

    # Create a new project by replacing the current one

   210

    def CreateNewProject(self, properties):

   211

        # Create the project

   212

        self.Project = plcopen.project()

   213

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

   214

        self.Project.setfileHeader(properties)

   215

        self.Project.setcontentHeader(properties)

   216

        self.SetFilePath("")

   217

        # Initialize the project buffer

   218

        self.CreateProjectBuffer(False)

   219

        self.ProgramChunks = []

   220

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

   221

        self.CurrentCompiledProject = None

   222

        self.Buffering = False

   223

   224

    # Return project data type names

   225

    def GetProjectDataTypeNames(self, debug = False):

   226

        project = self.GetProject(debug)

   227

        if project is not None:

   228

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

   229

        return []

   230

   231

    # Return project pou names

   232

    def GetProjectPouNames(self, debug = False):

   233

        project = self.GetProject(debug)

   234

        if project is not None:

   235

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

   236

        return []

   237

   238

    # Return project pou names

   239

    def GetProjectConfigNames(self, debug = False):

   240

        project = self.GetProject(debug)

   241

        if project is not None:

   242

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

   243

        return []

   244

   245

    # Return project pou variables

   246

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

   247

        variables = []

   248

        project = self.GetProject(debug)

   249

        if project is not None:

   250

            for pou in project.getpous():

   251

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

   252

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

   253

                    for transition in pou.gettransitionList():

   254

                        variables.append(transition.getname())

   255

                    for action in pou.getactionList():

   256

                        variables.append(action.getname())

   257

        return variables

   258

   259

    # Return file path if project is an open file

   260

    def GetFilePath(self):

   261

        return self.FilePath

   262

   263

    # Return file path if project is an open file

   264

    def GetProgramFilePath(self):

   265

        return self.ProgramFilePath

   266

   267

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

   268

    def GetFilename(self):

   269

        if self.Project is not None:

   270

            if self.ProjectIsSaved():

   271

                return self.FileName

   272

            else:

   273

                return "~%s~"%self.FileName

   274

        return ""

   275

   276

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

   277

    def SetFilePath(self, filepath):

   278

        self.FilePath = filepath

   279

        if filepath == "":

   280

            self.LastNewIndex += 1

   281

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

   282

        else:

   283

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

   284

   285

    # Change project properties

   286

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

   287

        if self.Project is not None:

   288

            if name is not None:

   289

                self.Project.setname(name)

   290

            if properties is not None:

   291

                self.Project.setfileHeader(properties)

   292

                self.Project.setcontentHeader(properties)

   293

            if name is not None or properties is not None:

   294

                self.BufferProject()

   295

   296

    # Return project properties

   297

    def GetProjectProperties(self, debug = False):

   298

        project = self.GetProject(debug)

   299

        if project is not None:

   300

            properties = project.getfileHeader()

   301

            properties.update(project.getcontentHeader())

   302

            return properties

   303

        return None

   304

   305

    # Return project informations

   306

    def GetProjectInfos(self, debug = False):

   307

        project = self.GetProject(debug)

   308

        if project is not None:

   309

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

   310

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

   311

            for datatype in project.getdataTypes():

   312

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

   313

                    "tagname": self.ComputeDataTypeName(datatype.getname()), "values": []})

   314

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

   315

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

   316

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

   317

            for pou in project.getpous():

   318

                pou_type = pou.getpouType()

   319

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

   320

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

   321

                pou_values = []

   322

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

   323

                    transitions = []

   324

                    for transition in pou.gettransitionList():

   325

                        transitions.append({"name": transition.getname(), "type": ITEM_TRANSITION, 

   326

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

   327

                            "values": []})

   328

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

   329

                    actions = []

   330

                    for action in pou.getactionList():

   331

                        actions.append({"name": action.getname(), "type": ITEM_ACTION, 

   332

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

   333

                            "values": []})

   334

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

   335

                if pou_type in pou_types:

   336

                    pou_infos["values"] = pou_values

   337

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

   338

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

   339

            for config in project.getconfigurations():

   340

                config_name = config.getname()

   341

                config_infos = {"name": config_name, "type": ITEM_CONFIGURATION, 

   342

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

   343

                    "values": []}

   344

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

   345

                for resource in config.getresource():

   346

                    resource_name = resource.getname()

   347

                    resource_infos = {"name": resource_name, "type": ITEM_RESOURCE, 

   348

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

   349

                        "values": []}

   350

                    resources["values"].append(resource_infos)

   351

                config_infos["values"] = [resources]

   352

                configurations["values"].append(config_infos)

   353

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

   354

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

   355

                               pou_types["program"], configurations]

   356

            return infos

   357

        return None

   358

   359

    # Return project topology informations

   360

    def GetProjectTopology(self, debug = False):

   361

        project = self.GetProject(debug)

   362

        if project is not None:

   363

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

   364

            for config in project.getconfigurations():

   365

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

   366

                for resource in config.getresource():

   367

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

   368

                    for task in resource.gettask():

   369

                        for pou in task.getpouInstance():

   370

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

   371

                            if instance_infos is not None:

   372

                                resource_infos["values"].append(instance_infos)

   373

                    for pou in resource.getpouInstance():

   374

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

   375

                        if instance_infos is not None:

   376

                            resource_infos["values"].append(instance_infos)

   377

                    for varlist in resource.getglobalVars():

   378

                        for variable in varlist.getvariable():

   379

                            vartype_content = variable.gettype().getcontent()

   380

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

   381

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

   382

                                if var_infos is not None:

   383

                                    resource_infos["values"].append(var_infos)

   384

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

   385

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

   386

                                                                 "elmt_type" : vartype_content["name"].upper(),

   387

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

   388

                            else:

   389

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

   390

                                                                 "elmt_type" : vartype_content["name"], 

   391

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

   392

                    config_infos["values"].append(resource_infos)

   393

                for varlist in config.getglobalVars():

   394

                    for variable in varlist.getvariable():

   395

                        vartype_content = variable.gettype().getcontent()

   396

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

   397

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

   398

                            if var_infos is not None:

   399

                                config_infos["values"].append(var_infos)

   400

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

   401

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

   402

                                                           "elmt_type" : vartype_content["name"].upper(), 

   403

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

   404

                        else:

   405

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

   406

                                                           "elmt_type" : vartype_content["name"], 

   407

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

   408

                infos["values"].append(config_infos)

   409

            return infos

   410

        return None

   411

   412

    # Return pou topology informations

   413

    def GetPouTopology(self, name, type, global_var = False, debug = False):

   414

        project = self.GetProject(debug)

   415

        if project is not None:

   416

            pou = project.getpou(type)

   417

            if pou is not None:

   418

                pou_type = pou.getpouType()

   419

                if pou_type == "function":

   420

                    return None

   421

                elif pou_type == "program":

   422

                    pou_infos = {"name" : name, "elmt_type" : type, "type" : ITEM_PROGRAM, 

   423

                                 "tagname" : self.ComputePouName(pou.getname()), "values" : []}

   424

                else:

   425

                    pou_infos = {"name" : name, "elmt_type" : type, "type" : ITEM_FUNCTIONBLOCK, 

   426

                                 "tagname" : self.ComputePouName(pou.getname()), "values" : []}

   427

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

   428

                    for transition in pou.gettransitionList():

   429

                        pou_infos["values"].append({"name" : transition.getname(), 

   430

                            "elmt_type" : "TRANSITION", "type" : ITEM_TRANSITION, 

   431

                            "tagname" : self.ComputePouActionName(pou.getname(), transition.getname()),

   432

                            "values" : []})

   433

                    for action in pou.getactionList():

   434

                        pou_infos["values"].append({"name": action.getname(), 

   435

                            "elmt_type" : "ACTION", "type": ITEM_ACTION, 

   436

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

   437

                            "values" : []})

   438

                if pou.interface:

   439

                    # Extract variables from every varLists

   440

                    for type, varlist in pou.getvars():

   441

                        infos = VAR_CLASS_INFOS.get(type, None)

   442

                        if infos is not None:

   443

                            current_var_class = infos[1]

   444

                        else:

   445

                            current_var_class = ITEM_VAR_LOCAL

   446

                        for variable in varlist.getvariable():

   447

                            vartype_content = variable.gettype().getcontent()

   448

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

   449

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

   450

                                if var_infos is not None:

   451

                                    pou_infos["values"].append(var_infos)

   452

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

   453

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

   454

                                                            "elmt_type" : vartype_content["name"].upper(), 

   455

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

   456

                            else:

   457

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

   458

                                                            "elmt_type" : vartype_content["name"], 

   459

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

   460

                return pou_infos

   461

            block_infos = self.GetBlockType(type, debug = debug)

   462

            if block_infos is not None:

   463

                if block_infos["type"] == "function":

   464

                    return None

   465

                elif block_infos["type"] == "program":

   466

                    pou_infos = {"name" : name, "elmt_type" : type, "type" : ITEM_PROGRAM, "values" : []}

   467

                else:

   468

                    pou_infos = {"name" : name, "elmt_type" : type, "type" : ITEM_FUNCTIONBLOCK, "values" : []}

   469

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

   470

                    pou_infos["values"].append({"name" : varname, "elmt_type" : vartype, "type" : ITEM_VAR_INPUT, "values" : []})

   471

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

   472

                    pou_infos["values"].append({"name" : varname, "elmt_type" : vartype, "type" : ITEM_VAR_INPUT, "values" : []})

   473

                return pou_infos

   474

   475

            if type in self.GetDataTypes(debug = debug):

   476

                if global_var:

   477

                    return {"name" : name, "elmt_type" : type, "type" : ITEM_VAR_GLOBAL, "values" : []}

   478

                else:

   479

                    return {"name" : name, "elmt_type" : type, "type" : ITEM_VAR_LOCAL, "values" : []}

   480

        return None

   481

   482

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

   483

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

   484

        project = self.GetProject(debug)

   485

        if project is not None:

   486

            return project.ElementIsUsed(name) or project.DataTypeIsDerived(name)

   487

        return False

   488

   489

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

   490

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

   491

        project = self.GetProject(debug)

   492

        if project is not None:

   493

            return project.ElementIsUsed(name)

   494

        return False

   495

   496

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

   497

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

   498