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 = True

   183

        self.Buffering = False

   184

        self.FilePath = ""

   185

        self.FileName = ""

   186

        self.ProgramChunks = []

   187

        self.ProgramOffset = 0

   188

        self.NextCompiledProject = None

   189

        self.CurrentCompiledProject = None

   190

        self.PluginTypes = []

   191

        self.ProgramFilePath = ""

   192

   193

    def GetQualifierTypes(self):

   194

        return plcopen.QualifierList

   195

   196

    def GetProject(self, debug = False):

   197

        if debug and self.CurrentCompiledProject is not None:

   198

            return self.CurrentCompiledProject

   199

        else:

   200

            return self.Project

   201

   202

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

   203

#                         Project management functions

   204

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

   205

   206

    # Return if a project is opened

   207

    def HasOpenedProject(self):

   208

        return self.Project is not None

   209

   210

    # Create a new project by replacing the current one

   211

    def CreateNewProject(self, properties):

   212

        # Create the project

   213

        self.Project = plcopen.project()

   214

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

   215

        self.Project.setfileHeader(properties)

   216

        self.Project.setcontentHeader(properties)

   217

        self.SetFilePath("")

   218

        # Initialize the project buffer

   219

        self.CreateProjectBuffer(False)

   220

        self.ProgramChunks = []

   221

        self.ProgramOffset = 0

   222

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

   223

        self.CurrentCompiledProject = None

   224

        self.Buffering = False

   225

   226

    # Return project data type names

   227

    def GetProjectDataTypeNames(self, debug = False):

   228

        project = self.GetProject(debug)

   229

        if project is not None:

   230

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

   231

        return []

   232

   233

    # Return project pou names

   234

    def GetProjectPouNames(self, debug = False):

   235

        project = self.GetProject(debug)

   236

        if project is not None:

   237

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

   238

        return []

   239

   240

    # Return project pou names

   241

    def GetProjectConfigNames(self, debug = False):

   242

        project = self.GetProject(debug)

   243

        if project is not None:

   244

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

   245

        return []

   246

   247

    # Return project pou variables

   248

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

   249

        variables = []

   250

        project = self.GetProject(debug)

   251

        if project is not None:

   252

            for pou in project.getpous():

   253

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

   254

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

   255

                    for transition in pou.gettransitionList():

   256

                        variables.append(transition.getname())

   257

                    for action in pou.getactionList():

   258

                        variables.append(action.getname())

   259

        return variables

   260

   261

    # Return file path if project is an open file

   262

    def GetFilePath(self):

   263

        return self.FilePath

   264

   265

    # Return file path if project is an open file

   266

    def GetProgramFilePath(self):

   267

        return self.ProgramFilePath

   268

   269

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

   270

    def GetFilename(self):

   271

        if self.Project is not None:

   272

            if self.ProjectIsSaved():

   273

                return self.FileName

   274

            else:

   275

                return "~%s~"%self.FileName

   276

        return ""

   277

   278

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

   279

    def SetFilePath(self, filepath):

   280

        self.FilePath = filepath

   281

        if filepath == "":

   282

            self.LastNewIndex += 1

   283

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

   284

        else:

   285

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

   286

   287

    # Change project properties

   288

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

   289

        if self.Project is not None:

   290

            if name is not None:

   291

                self.Project.setname(name)

   292

            if properties is not None:

   293

                self.Project.setfileHeader(properties)

   294

                self.Project.setcontentHeader(properties)

   295

            if name is not None or properties is not None:

   296

                self.BufferProject()

   297

   298

    # Return project properties

   299

    def GetProjectProperties(self, debug = False):

   300

        project = self.GetProject(debug)

   301

        if project is not None:

   302

            properties = project.getfileHeader()

   303

            properties.update(project.getcontentHeader())

   304

            return properties

   305

        return None

   306

   307

    # Return project informations

   308

    def GetProjectInfos(self, debug = False):

   309

        project = self.GetProject(debug)

   310

        if project is not None:

   311

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

   312

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

   313

            for datatype in project.getdataTypes():

   314

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

   315

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

   316

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

   317

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

   318

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

   319

            for pou in project.getpous():

   320

                pou_type = pou.getpouType()

   321

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

   322

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

   323

                pou_values = []

   324

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

   325

                    transitions = []

   326

                    for transition in pou.gettransitionList():

   327

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

   328

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

   329

                            "values": []})

   330

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

   331

                    actions = []

   332

                    for action in pou.getactionList():

   333

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

   334

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

   335

                            "values": []})

   336

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

   337

                if pou_type in pou_types:

   338

                    pou_infos["values"] = pou_values

   339

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

   340

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

   341

            for config in project.getconfigurations():

   342

                config_name = config.getname()

   343

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

   344

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

   345

                    "values": []}

   346

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

   347

                for resource in config.getresource():

   348

                    resource_name = resource.getname()

   349

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

   350

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

   351

                        "values": []}

   352

                    resources["values"].append(resource_infos)

   353

                config_infos["values"] = [resources]

   354

                configurations["values"].append(config_infos)

   355

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

   356

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

   357

                               pou_types["program"], configurations]

   358

            return infos

   359

        return None

   360

   361

    # Return project topology informations

   362

    def GetProjectTopology(self, debug = False):

   363

        project = self.GetProject(debug)

   364

        if project is not None:

   365

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

   366

            for config in project.getconfigurations():

   367

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

   368

                for resource in config.getresource():

   369

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

   370

                    for task in resource.gettask():

   371

                        for pou in task.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 pou in resource.getpouInstance():

   376

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

   377

                        if instance_infos is not None:

   378

                            resource_infos["values"].append(instance_infos)

   379

                    for varlist in resource.getglobalVars():

   380

                        for variable in varlist.getvariable():

   381

                            vartype_content = variable.gettype().getcontent()

   382

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

   383

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

   384

                                if var_infos is not None:

   385

                                    resource_infos["values"].append(var_infos)

   386

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

   387

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

   388

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

   389

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

   390

                            else:

   391

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

   392

                                                                 "elmt_type" : vartype_content["name"], 

   393

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

   394

                    config_infos["values"].append(resource_infos)

   395

                for varlist in config.getglobalVars():

   396

                    for variable in varlist.getvariable():

   397

                        vartype_content = variable.gettype().getcontent()

   398

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

   399

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

   400

                            if var_infos is not None:

   401

                                config_infos["values"].append(var_infos)

   402

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

   403

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

   404

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

   405

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

   406

                        else:

   407

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

   408

                                                           "elmt_type" : vartype_content["name"], 

   409

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

   410

                infos["values"].append(config_infos)

   411

            return infos

   412

        return None

   413

   414

    # Return pou topology informations

   415

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

   416

        project = self.GetProject(debug)

   417

        if project is not None:

   418

            pou = project.getpou(type)

   419

            if pou is not None:

   420

                pou_type = pou.getpouType()

   421

                if pou_type == "function":

   422

                    return None

   423

                elif pou_type == "program":

   424

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

   425

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

   426

                else:

   427

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

   428

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

   429

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

   430

                    for transition in pou.gettransitionList():

   431

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

   432

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

   433

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

   434

                            "values" : []})

   435

                    for action in pou.getactionList():

   436

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

   437

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

   438

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

   439

                            "values" : []})

   440

                if pou.interface:

   441

                    # Extract variables from every varLists

   442

                    for type, varlist in pou.getvars():

   443

                        infos = VAR_CLASS_INFOS.get(type, None)

   444

                        if infos is not None:

   445

                            current_var_class = infos[1]

   446

                        else:

   447

                            current_var_class = ITEM_VAR_LOCAL

   448

                        for variable in varlist.getvariable():

   449

                            vartype_content = variable.gettype().getcontent()

   450

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

   451

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

   452

                                if var_infos is not None:

   453

                                    pou_infos["values"].append(var_infos)

   454

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

   455

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

   456

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

   457

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

   458

                            else:

   459

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

   460

                                                            "elmt_type" : vartype_content["name"], 

   461

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

   462

                return pou_infos

   463

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

   464

            if block_infos is not None:

   465

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

   466

                    return None

   467

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

   468

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

   469

                else:

   470

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

   471

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

   472

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

   473

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

   474

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

   475

                return pou_infos

   476

   477

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

   478

                if global_var:

   479

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

   480

                else:

   481

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

   482

        return None

   483

   484

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

   485

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

   486

        project = self.GetProject(debug)

   487

        if project is not None:

   488

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

   489

        return False

   490

   491

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

   492

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

   493

        project = self.GetProject(debug)

   494

        if project is not None:

   495

            return project.ElementIsUsed(name)

   496

        return False

   497

   498