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

import datetime

    30

from time import localtime

    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

def GetUneditableNames():

    81

    _ = lambda x:x

    82

    return [_("User-defined POUs"), _("Functions"), _("Function Blocks"), 

    83

            _("Programs"), _("Data Types"), _("Transitions"), _("Actions"), 

    84

            _("Configurations"), _("Resources"), _("Properties")]

    85

UNEDITABLE_NAMES = GetUneditableNames()

    86

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS, 

    87

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS, 

    88

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

    89

    90

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

    91

#                         Undo Buffer for PLCOpenEditor

    92

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

    93

    94

# Length of the buffer

    95

UNDO_BUFFER_LENGTH = 20

    96

    97

"""

    98

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

    99

"""

   100

class UndoBuffer:

   101

   102

    # Constructor initialising buffer

   103

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

   104

        self.Buffer = []

   105

        self.CurrentIndex = -1

   106

        self.MinIndex = -1

   107

        self.MaxIndex = -1

   108

        # if current state is defined

   109

        if currentstate:

   110

            self.CurrentIndex = 0

   111

            self.MinIndex = 0

   112

            self.MaxIndex = 0

   113

        # Initialising buffer with currentstate at the first place

   114

        for i in xrange(UNDO_BUFFER_LENGTH):

   115

            if i == 0:

   116

                self.Buffer.append(currentstate)

   117

            else:

   118

                self.Buffer.append(None)

   119

        # Initialising index of state saved

   120

        if issaved:

   121

            self.LastSave = 0

   122

        else:

   123

            self.LastSave = -1

   124

   125

    # Add a new state in buffer

   126

    def Buffering(self, currentstate):

   127

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

   128

        self.Buffer[self.CurrentIndex] = currentstate

   129

        # Actualising buffer limits

   130

        self.MaxIndex = self.CurrentIndex

   131

        if self.MinIndex == self.CurrentIndex:

   132

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

   133

            if self.LastSave == self.MinIndex:

   134

                self.LastSave = -1

   135

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

   136

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

   137

   138

    # Return current state of buffer

   139

    def Current(self):

   140

        return self.Buffer[self.CurrentIndex]

   141

   142

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

   143

    def Previous(self):

   144

        if self.CurrentIndex != self.MinIndex:

   145

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

   146

            return self.Buffer[self.CurrentIndex]

   147

        return None

   148

   149

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

   150

    def Next(self):

   151

        if self.CurrentIndex != self.MaxIndex:

   152

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

   153

            return self.Buffer[self.CurrentIndex]

   154

        return None

   155

   156

    # Return True if current state is the first in buffer

   157

    def IsFirst(self):

   158

        return self.CurrentIndex == self.MinIndex

   159

   160

    # Return True if current state is the last in buffer

   161

    def IsLast(self):

   162

        return self.CurrentIndex == self.MaxIndex

   163

   164

    # Note that current state is saved

   165

    def CurrentSaved(self):

   166

        self.LastSave = self.CurrentIndex

   167

   168

    # Return True if current state is saved

   169

    def IsCurrentSaved(self):

   170

        return self.LastSave == self.CurrentIndex

   171

   172

   173

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

   174

#                           Controler for PLCOpenEditor

   175

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

   176

   177

"""

   178

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

   179

"""

   180

class PLCControler:

   181

   182

    # Create a new PLCControler

   183

    def __init__(self):

   184

        self.LastNewIndex = 0

   185

        self.Reset()

   186

   187

    # Reset PLCControler internal variables

   188

    def Reset(self):

   189

        self.Project = None

   190

        self.ProjectBufferEnabled = False

   191

        self.ProjectBuffer = None

   192

        self.ProjectSaved = True

   193

        self.Buffering = False

   194

        self.FilePath = ""

   195

        self.FileName = ""

   196

        self.ProgramChunks = []

   197

        self.ProgramOffset = 0

   198

        self.NextCompiledProject = None

   199

        self.CurrentCompiledProject = None

   200

        self.PluginTypes = []

   201

        self.ProgramFilePath = ""

   202

   203

    def GetQualifierTypes(self):

   204

        return plcopen.QualifierList

   205

   206

    def GetProject(self, debug = False):

   207

        if debug and self.CurrentCompiledProject is not None:

   208

            return self.CurrentCompiledProject

   209

        else:

   210

            return self.Project

   211

   212

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

   213

#                         Project management functions

   214

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

   215

   216

    # Return if a project is opened

   217

    def HasOpenedProject(self):

   218

        return self.Project is not None

   219

   220

    # Create a new project by replacing the current one

   221

    def CreateNewProject(self, properties):

   222

        # Create the project

   223

        self.Project = plcopen.project()

   224

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

   225

        self.Project.setfileHeader(properties)

   226

        self.Project.setcontentHeader(properties)

   227

        self.SetFilePath("")

   228

        # Initialize the project buffer

   229

        self.CreateProjectBuffer(False)

   230

        self.ProgramChunks = []

   231

        self.ProgramOffset = 0

   232

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

   233

        self.CurrentCompiledProject = None

   234

        self.Buffering = False

   235

   236

    # Return project data type names

   237

    def GetProjectDataTypeNames(self, debug = False):

   238

        project = self.GetProject(debug)

   239

        if project is not None:

   240

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

   241

        return []

   242

   243

    # Return project pou names

   244

    def GetProjectPouNames(self, debug = False):

   245

        project = self.GetProject(debug)

   246

        if project is not None:

   247

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

   248

        return []

   249

   250

    # Return project pou names

   251

    def GetProjectConfigNames(self, debug = False):

   252

        project = self.GetProject(debug)

   253

        if project is not None:

   254

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

   255

        return []

   256

   257

    # Return project pou variables

   258

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

   259

        variables = []

   260

        project = self.GetProject(debug)

   261

        if project is not None:

   262

            for pou in project.getpous():

   263

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

   264

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

   265

                    for transition in pou.gettransitionList():

   266

                        variables.append(transition.getname())

   267

                    for action in pou.getactionList():

   268

                        variables.append(action.getname())

   269

        return variables

   270

   271

    # Return file path if project is an open file

   272

    def GetFilePath(self):

   273

        return self.FilePath

   274

   275

    # Return file path if project is an open file

   276

    def GetProgramFilePath(self):

   277

        return self.ProgramFilePath

   278

   279

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

   280

    def GetFilename(self):

   281

        if self.Project is not None:

   282

            if self.ProjectIsSaved():

   283

                return self.FileName

   284

            else:

   285

                return "~%s~"%self.FileName

   286

        return ""

   287

   288

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

   289

    def SetFilePath(self, filepath):

   290

        self.FilePath = filepath

   291

        if filepath == "":

   292

            self.LastNewIndex += 1

   293

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

   294

        else:

   295

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

   296

   297

    # Change project properties

   298

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

   299

        if self.Project is not None:

   300

            if name is not None:

   301

                self.Project.setname(name)

   302

            if properties is not None:

   303

                self.Project.setfileHeader(properties)

   304

                self.Project.setcontentHeader(properties)

   305

            if name is not None or properties is not None:

   306

                self.BufferProject()

   307

   308

    # Return project properties

   309

    def GetProjectProperties(self, debug = False):

   310

        project = self.GetProject(debug)

   311

        if project is not None:

   312

            properties = project.getfileHeader()

   313

            properties.update(project.getcontentHeader())

   314

            return properties

   315

        return None

   316

   317

    # Return project informations

   318

    def GetProjectInfos(self, debug = False):

   319

        project = self.GetProject(debug)

   320

        if project is not None:

   321

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

   322

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

   323

            for datatype in project.getdataTypes():

   324

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

   325

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

   326

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

   327

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

   328

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

   329

            for pou in project.getpous():

   330

                pou_type = pou.getpouType()

   331

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

   332

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

   333

                pou_values = []

   334

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

   335

                    transitions = []

   336

                    for transition in pou.gettransitionList():

   337

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

   338

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

   339

                            "values": []})

   340

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

   341

                    actions = []

   342

                    for action in pou.getactionList():

   343

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

   344

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

   345

                            "values": []})

   346

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

   347

                if pou_type in pou_types:

   348

                    pou_infos["values"] = pou_values

   349

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

   350

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

   351

            for config in project.getconfigurations():

   352

                config_name = config.getname()

   353

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

   354

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

   355

                    "values": []}

   356

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

   357

                for resource in config.getresource():

   358

                    resource_name = resource.getname()

   359

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

   360

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

   361

                        "values": []}

   362

                    resources["values"].append(resource_infos)

   363

                config_infos["values"] = [resources]

   364

                configurations["values"].append(config_infos)

   365

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

   366

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

   367

                               pou_types["program"], configurations]

   368

            return infos

   369

        return None

   370

   371

    # Return project topology informations

   372

    def GetProjectTopology(self, debug = False):

   373

        project = self.GetProject(debug)

   374

        if project is not None:

   375

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

   376

            for config in project.getconfigurations():

   377

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

   378

                for resource in config.getresource():

   379

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

   380

                    for task in resource.gettask():

   381

                        for pou in task.getpouInstance():

   382

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

   383

                            if instance_infos is not None:

   384

                                resource_infos["values"].append(instance_infos)

   385

                    for pou in resource.getpouInstance():

   386

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

   387

                        if instance_infos is not None:

   388

                            resource_infos["values"].append(instance_infos)

   389

                    for varlist in resource.getglobalVars():

   390

                        for variable in varlist.getvariable():

   391

                            vartype_content = variable.gettype().getcontent()

   392

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

   393

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

   394

                                if var_infos is not None:

   395

                                    resource_infos["values"].append(var_infos)

   396

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

   397

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

   398

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

   399

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

   400

                            else:

   401

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

   402

                                                                 "elmt_type" : vartype_content["name"], 

   403

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

   404

                    config_infos["values"].append(resource_infos)

   405

                for varlist in config.getglobalVars():

   406

                    for variable in varlist.getvariable():

   407

                        vartype_content = variable.gettype().getcontent()

   408

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

   409

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

   410

                            if var_infos is not None:

   411

                                config_infos["values"].append(var_infos)

   412

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

   413

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

   414

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

   415

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

   416

                        else:

   417

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

   418

                                                           "elmt_type" : vartype_content["name"], 

   419

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

   420

                infos["values"].append(config_infos)

   421

            return infos

   422

        return None

   423

   424

    # Return pou topology informations

   425

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

   426

        project = self.GetProject(debug)

   427

        if project is not None:

   428

            pou = project.getpou(type)

   429

            if pou is not None:

   430

                pou_type = pou.getpouType()

   431

                if pou_type == "function":

   432

                    return None

   433

                elif pou_type == "program":

   434

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

   435

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

   436

                else:

   437

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

   438

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

   439

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

   440

                    for transition in pou.gettransitionList():

   441

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

   442

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

   443

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

   444

                            "values" : []})

   445

                    for action in pou.getactionList():

   446

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

   447

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

   448

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

   449

                            "values" : []})

   450

                if pou.interface:

   451

                    # Extract variables from every varLists

   452

                    for type, varlist in pou.getvars():

   453

                        infos = VAR_CLASS_INFOS.get(type, None)

   454

                        if infos is not None:

   455

                            current_var_class = infos[1]

   456

                        else:

   457

                            current_var_class = ITEM_VAR_LOCAL

   458

                        for variable in varlist.getvariable():

   459

                            vartype_content = variable.gettype().getcontent()

   460

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

   461

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

   462

                                if var_infos is not None:

   463

                                    pou_infos["values"].append(var_infos)

   464

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

   465

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

   466

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

   467

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

   468

                            else:

   469

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

   470

                                                            "elmt_type" : vartype_content["name"], 

   471

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

   472

                return pou_infos

   473

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

   474

            if block_infos is not None:

   475

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

   476

                    return None

   477

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

   478

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

   479

                else:

   480

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

   481

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

   482

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

   483

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

   484

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

   485

                return pou_infos

   486

   487

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

   488

                if global_var:

   489

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

   490

                else:

   491

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

   492

        return None

   493

   494

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

   495

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

   496

        project = self.GetProject(debug)

   497

        if project is not None: