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.ProjectBuffer = None

   181

        self.Buffering = False

   182

        self.FilePath = ""

   183

        self.FileName = ""

   184

        self.ProgramChunks = []

   185

        self.NextCompiledProject = None

   186

        self.CurrentCompiledProject = None

   187

        self.PluginTypes = []

   188

        self.ProgramFilePath = ""

   189

   190

    def GetQualifierTypes(self):

   191

        return plcopen.QualifierList

   192

   193

    def GetProject(self, debug = False):

   194

        if debug and self.CurrentCompiledProject is not None:

   195

            return self.CurrentCompiledProject

   196

        else:

   197

            return self.Project

   198

   199

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

   200

#                         Project management functions

   201

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

   202

   203

    # Return if a project is opened

   204

    def HasOpenedProject(self):

   205

        return self.Project is not None

   206

   207

    # Create a new project by replacing the current one

   208

    def CreateNewProject(self, properties):

   209

        # Create the project

   210

        self.Project = plcopen.project()

   211

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

   212

        self.Project.setfileHeader(properties)

   213

        self.Project.setcontentHeader(properties)

   214

        self.SetFilePath("")

   215

        # Initialize the project buffer

   216

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

   217

        self.ProgramChunks = []

   218

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

   219

        self.CurrentCompiledProject = None

   220

        self.Buffering = False

   221

   222

    # Return project data type names

   223

    def GetProjectDataTypeNames(self, debug = False):

   224

        project = self.GetProject(debug)

   225

        if project is not None:

   226

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

   227

        return []

   228

   229

    # Return project pou names

   230

    def GetProjectPouNames(self, debug = False):

   231

        project = self.GetProject(debug)

   232

        if project is not None:

   233

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

   234

        return []

   235

   236

    # Return project pou names

   237

    def GetProjectConfigNames(self, debug = False):

   238

        project = self.GetProject(debug)

   239

        if project is not None:

   240

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

   241

        return []

   242

   243

    # Return project pou variables

   244

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

   245

        variables = []

   246

        project = self.GetProject(debug)

   247

        if project is not None:

   248

            for pou in project.getpous():

   249

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

   250

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

   251

                    for transition in pou.gettransitionList():

   252

                        variables.append(transition.getname())

   253

                    for action in pou.getactionList():

   254

                        variables.append(action.getname())

   255

        return variables

   256

   257

    # Return file path if project is an open file

   258

    def GetFilePath(self):

   259

        return self.FilePath

   260

   261

    # Return file path if project is an open file

   262

    def GetProgramFilePath(self):

   263

        return self.ProgramFilePath

   264

   265

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

   266

    def GetFilename(self):

   267

        if self.Project is not None:

   268

            if self.ProjectBuffer.IsCurrentSaved():

   269

                return self.FileName

   270

            else:

   271

                return "~%s~"%self.FileName

   272

        return ""

   273

   274

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

   275

    def SetFilePath(self, filepath):

   276

        self.FilePath = filepath

   277

        if filepath == "":

   278

            self.LastNewIndex += 1

   279

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

   280

        else:

   281

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

   282

   283

    # Change project properties

   284

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

   285

        if self.Project is not None:

   286

            if name is not None:

   287

                self.Project.setname(name)

   288

            if properties is not None:

   289

                self.Project.setfileHeader(properties)

   290

                self.Project.setcontentHeader(properties)

   291

            if name is not None or properties is not None:

   292

                self.BufferProject()

   293

   294

    # Return project properties

   295

    def GetProjectProperties(self, debug = False):

   296

        project = self.GetProject(debug)

   297

        if project is not None:

   298

            properties = project.getfileHeader()

   299

            properties.update(project.getcontentHeader())

   300

            return properties

   301

        return None

   302

   303

    # Return project informations

   304

    def GetProjectInfos(self, debug = False):

   305

        project = self.GetProject(debug)

   306

        if project is not None:

   307

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

   308

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

   309

            for datatype in project.getdataTypes():

   310

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

   311

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

   312

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

   313

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

   314

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

   315

            for pou in project.getpous():

   316

                pou_type = pou.getpouType()

   317

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

   318

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

   319

                pou_values = []

   320

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

   321

                    transitions = []

   322

                    for transition in pou.gettransitionList():

   323

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

   324

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

   325

                            "values": []})

   326

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

   327

                    actions = []

   328

                    for action in pou.getactionList():

   329

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

   330

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

   331

                            "values": []})

   332

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

   333

                if pou_type in pou_types:

   334

                    pou_infos["values"] = pou_values

   335

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

   336

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

   337

            for config in project.getconfigurations():

   338

                config_name = config.getname()

   339

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

   340

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

   341

                    "values": []}

   342

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

   343

                for resource in config.getresource():

   344

                    resource_name = resource.getname()

   345

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

   346

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

   347

                        "values": []}

   348

                    resources["values"].append(resource_infos)

   349

                config_infos["values"] = [resources]

   350

                configurations["values"].append(config_infos)

   351

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

   352

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

   353

                               pou_types["program"], configurations]

   354

            return infos

   355

        return None

   356

   357

    # Return project topology informations

   358

    def GetProjectTopology(self, debug = False):

   359

        project = self.GetProject(debug)

   360

        if project is not None:

   361

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

   362

            for config in project.getconfigurations():

   363

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

   364

                for resource in config.getresource():

   365

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

   366

                    for task in resource.gettask():

   367

                        for pou in task.getpouInstance():

   368

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

   369

                            if instance_infos is not None:

   370

                                resource_infos["values"].append(instance_infos)

   371

                    for pou in resource.getpouInstance():

   372

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

   373

                        if instance_infos is not None:

   374

                            resource_infos["values"].append(instance_infos)

   375

                    for varlist in resource.getglobalVars():

   376

                        for variable in varlist.getvariable():

   377

                            vartype_content = variable.gettype().getcontent()

   378

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

   379

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

   380

                                if var_infos is not None:

   381

                                    resource_infos["values"].append(var_infos)

   382

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

   383

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

   384

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

   385

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

   386

                            else:

   387

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

   388

                                                                 "elmt_type" : vartype_content["name"], 

   389

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

   390

                    config_infos["values"].append(resource_infos)

   391

                for varlist in config.getglobalVars():

   392

                    for variable in varlist.getvariable():

   393

                        vartype_content = variable.gettype().getcontent()

   394

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

   395

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

   396

                            if var_infos is not None:

   397

                                config_infos["values"].append(var_infos)

   398

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

   399

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

   400

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

   401

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

   402

                        else:

   403

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

   404

                                                           "elmt_type" : vartype_content["name"], 

   405

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

   406

                infos["values"].append(config_infos)

   407

            return infos

   408

        return None

   409

   410

    # Return pou topology informations

   411

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

   412

        project = self.GetProject(debug)

   413

        if project is not None:

   414

            pou = project.getpou(type)

   415

            if pou is not None:

   416

                pou_type = pou.getpouType()

   417

                if pou_type == "function":

   418

                    return None

   419

                elif pou_type == "program":

   420

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

   421

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

   422

                else:

   423

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

   424

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

   425

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

   426

                    for transition in pou.gettransitionList():

   427

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

   428

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

   429

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

   430

                            "values" : []})

   431

                    for action in pou.getactionList():

   432

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

   433

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

   434

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

   435

                            "values" : []})

   436

                if pou.interface:

   437

                    # Extract variables from every varLists

   438

                    for type, varlist in pou.getvars():

   439

                        infos = VAR_CLASS_INFOS.get(type, None)

   440

                        if infos is not None:

   441

                            current_var_class = infos[1]

   442

                        else:

   443

                            current_var_class = ITEM_VAR_LOCAL

   444

                        for variable in varlist.getvariable():

   445

                            vartype_content = variable.gettype().getcontent()

   446

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

   447

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

   448

                                if var_infos is not None:

   449

                                    pou_infos["values"].append(var_infos)

   450

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

   451

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

   452

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

   453

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

   454

                            else:

   455

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

   456

                                                            "elmt_type" : vartype_content["name"], 

   457

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

   458

                return pou_infos

   459

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

   460

            if block_infos is not None:

   461

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

   462

                    return None

   463

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

   464

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

   465

                else:

   466

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

   467

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

   468

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

   469

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

   470

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

   471

                return pou_infos

   472

   473

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

   474

                if global_var:

   475

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

   476

                else:

   477

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

   478

        return None

   479

   480

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

   481

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

   482

        project = self.GetProject(debug)

   483

        if project is not None:

   484

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

   485

        return False

   486

   487

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

   488

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

   489

        project = self.GetProject(debug)

   490

        if project is not None:

   491

            return project.ElementIsUsed(name)

   492

        return False

   493

   494

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

   495

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

   496

        project = self.GetProject(debug)

   497

        if project is not None:

   498

            return project.ElementIsUsedBy(name, reference)