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, TupleType

    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

LOCATIONS_ITEMS = [LOCATION_PLUGIN,

    79

                   LOCATION_MODULE,

    80

                   LOCATION_GROUP,

    81

                   LOCATION_VAR_INPUT,

    82

                   LOCATION_VAR_OUTPUT,

    83

                   LOCATION_VAR_MEMORY] = range(6)

    84

    85

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

    86

    87

def GetUneditableNames():

    88

    _ = lambda x:x

    89

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

    90

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

    91

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

    92

UNEDITABLE_NAMES = GetUneditableNames()

    93

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS, 

    94

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS, 

    95

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

    96

    97

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

    98

#                         Undo Buffer for PLCOpenEditor

    99

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

   100

   101

# Length of the buffer

   102

UNDO_BUFFER_LENGTH = 20

   103

   104

"""

   105

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

   106

"""

   107

class UndoBuffer:

   108

   109

    # Constructor initialising buffer

   110

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

   111

        self.Buffer = []

   112

        self.CurrentIndex = -1

   113

        self.MinIndex = -1

   114

        self.MaxIndex = -1

   115

        # if current state is defined

   116

        if currentstate:

   117

            self.CurrentIndex = 0

   118

            self.MinIndex = 0

   119

            self.MaxIndex = 0

   120

        # Initialising buffer with currentstate at the first place

   121

        for i in xrange(UNDO_BUFFER_LENGTH):

   122

            if i == 0:

   123

                self.Buffer.append(currentstate)

   124

            else:

   125

                self.Buffer.append(None)

   126

        # Initialising index of state saved

   127

        if issaved:

   128

            self.LastSave = 0

   129

        else:

   130

            self.LastSave = -1

   131

   132

    # Add a new state in buffer

   133

    def Buffering(self, currentstate):

   134

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

   135

        self.Buffer[self.CurrentIndex] = currentstate

   136

        # Actualising buffer limits

   137

        self.MaxIndex = self.CurrentIndex

   138

        if self.MinIndex == self.CurrentIndex:

   139

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

   140

            if self.LastSave == self.MinIndex:

   141

                self.LastSave = -1

   142

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

   143

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

   144

   145

    # Return current state of buffer

   146

    def Current(self):

   147

        return self.Buffer[self.CurrentIndex]

   148

   149

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

   150

    def Previous(self):

   151

        if self.CurrentIndex != self.MinIndex:

   152

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

   153

            return self.Buffer[self.CurrentIndex]

   154

        return None

   155

   156

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

   157

    def Next(self):

   158

        if self.CurrentIndex != self.MaxIndex:

   159

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

   160

            return self.Buffer[self.CurrentIndex]

   161

        return None

   162

   163

    # Return True if current state is the first in buffer

   164

    def IsFirst(self):

   165

        return self.CurrentIndex == self.MinIndex

   166

   167

    # Return True if current state is the last in buffer

   168

    def IsLast(self):

   169

        return self.CurrentIndex == self.MaxIndex

   170

   171

    # Note that current state is saved

   172

    def CurrentSaved(self):

   173

        self.LastSave = self.CurrentIndex

   174

   175

    # Return True if current state is saved

   176

    def IsCurrentSaved(self):

   177

        return self.LastSave == self.CurrentIndex

   178

   179

   180

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

   181

#                           Controler for PLCOpenEditor

   182

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

   183

   184

"""

   185

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

   186

"""

   187

class PLCControler:

   188

   189

    # Create a new PLCControler

   190

    def __init__(self):

   191

        self.LastNewIndex = 0

   192

        self.Reset()

   193

   194

    # Reset PLCControler internal variables

   195

    def Reset(self):

   196

        self.Project = None

   197

        self.ProjectBufferEnabled = True

   198

        self.ProjectBuffer = None

   199

        self.ProjectSaved = True

   200

        self.Buffering = False

   201

        self.FilePath = ""

   202

        self.FileName = ""

   203

        self.ProgramChunks = []

   204

        self.ProgramOffset = 0

   205

        self.NextCompiledProject = None

   206

        self.CurrentCompiledProject = None

   207

        self.PluginTypes = []

   208

        self.ProgramFilePath = ""

   209

   210

    def GetQualifierTypes(self):

   211

        return plcopen.QualifierList

   212

   213

    def GetProject(self, debug = False):

   214

        if debug and self.CurrentCompiledProject is not None:

   215

            return self.CurrentCompiledProject

   216

        else:

   217

            return self.Project

   218

   219

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

   220

#                         Project management functions

   221

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

   222

   223

    # Return if a project is opened

   224

    def HasOpenedProject(self):

   225

        return self.Project is not None

   226

   227

    # Create a new project by replacing the current one

   228

    def CreateNewProject(self, properties):

   229

        # Create the project

   230

        self.Project = plcopen.project()

   231

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

   232

        self.Project.setfileHeader(properties)

   233

        self.Project.setcontentHeader(properties)

   234

        self.SetFilePath("")

   235

        # Initialize the project buffer

   236

        self.CreateProjectBuffer(False)

   237

        self.ProgramChunks = []

   238

        self.ProgramOffset = 0

   239

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

   240

        self.CurrentCompiledProject = None

   241

        self.Buffering = False

   242

   243

    # Return project data type names

   244

    def GetProjectDataTypeNames(self, debug = False):

   245

        project = self.GetProject(debug)

   246

        if project is not None:

   247

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

   248

        return []

   249

   250

    # Return project pou names

   251

    def GetProjectPouNames(self, debug = False):

   252

        project = self.GetProject(debug)

   253

        if project is not None:

   254

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

   255

        return []

   256

   257

    # Return project pou names

   258

    def GetProjectConfigNames(self, debug = False):

   259

        project = self.GetProject(debug)

   260

        if project is not None:

   261

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

   262

        return []

   263

   264

    # Return project pou variables

   265

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

   266

        variables = []

   267

        project = self.GetProject(debug)

   268

        if project is not None:

   269

            for pou in project.getpous():

   270

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

   271

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

   272

                    for transition in pou.gettransitionList():

   273

                        variables.append(transition.getname())

   274

                    for action in pou.getactionList():

   275

                        variables.append(action.getname())

   276

        return variables

   277

   278

    # Return file path if project is an open file

   279

    def GetFilePath(self):

   280

        return self.FilePath

   281

   282

    # Return file path if project is an open file

   283

    def GetProgramFilePath(self):

   284

        return self.ProgramFilePath

   285

   286

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

   287

    def GetFilename(self):

   288

        if self.Project is not None:

   289

            if self.ProjectIsSaved():

   290

                return self.FileName

   291

            else:

   292

                return "~%s~"%self.FileName

   293

        return ""

   294

   295

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

   296

    def SetFilePath(self, filepath):

   297

        self.FilePath = filepath

   298

        if filepath == "":

   299

            self.LastNewIndex += 1

   300

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

   301

        else:

   302

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

   303

   304

    # Change project properties

   305

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

   306

        if self.Project is not None:

   307

            if name is not None:

   308

                self.Project.setname(name)

   309

            if properties is not None:

   310

                self.Project.setfileHeader(properties)

   311

                self.Project.setcontentHeader(properties)

   312

            if name is not None or properties is not None:

   313

                self.BufferProject()

   314

   315

    # Return project name

   316

    def GetProjectName(self, debug=False):

   317

        project = self.GetProject(debug)

   318

        if project is not None:

   319

            return project.getname()

   320

        return None

   321

   322

    # Return project properties

   323

    def GetProjectProperties(self, debug = False):

   324

        project = self.GetProject(debug)

   325

        if project is not None:

   326

            properties = project.getfileHeader()

   327

            properties.update(project.getcontentHeader())

   328

            return properties

   329

        return None

   330

   331

    # Return project informations

   332

    def GetProjectInfos(self, debug = False):

   333

        project = self.GetProject(debug)

   334

        if project is not None:

   335

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

   336

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

   337

            for datatype in project.getdataTypes():

   338

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

   339

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

   340

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

   341

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

   342

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

   343

            for pou in project.getpous():

   344

                pou_type = pou.getpouType()

   345

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

   346

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

   347

                pou_values = []

   348

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

   349

                    transitions = []

   350

                    for transition in pou.gettransitionList():

   351

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

   352

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

   353

                            "values": []})

   354

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

   355

                    actions = []

   356

                    for action in pou.getactionList():

   357

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

   358

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

   359

                            "values": []})

   360

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

   361

                if pou_type in pou_types:

   362

                    pou_infos["values"] = pou_values

   363

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

   364

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

   365

            for config in project.getconfigurations():

   366

                config_name = config.getname()

   367

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

   368

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

   369

                    "values": []}

   370

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

   371

                for resource in config.getresource():

   372

                    resource_name = resource.getname()

   373

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

   374

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

   375

                        "values": []}

   376

                    resources["values"].append(resource_infos)

   377

                config_infos["values"] = [resources]

   378

                configurations["values"].append(config_infos)

   379

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

   380

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

   381

                               pou_types["program"], configurations]

   382

            return infos

   383

        return None

   384

   385

    # Return project topology informations

   386

    def GetProjectTopology(self, debug = False):

   387

        project = self.GetProject(debug)

   388

        if project is not None:

   389

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

   390

            for config in project.getconfigurations():

   391

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

   392

                for resource in config.getresource():

   393

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

   394

                    for task in resource.gettask():

   395

                        for pou in task.getpouInstance():

   396

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

   397

                            if instance_infos is not None:

   398

                                resource_infos["values"].append(instance_infos)

   399

                    for pou in resource.getpouInstance():

   400

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

   401

                        if instance_infos is not None:

   402

                            resource_infos["values"].append(instance_infos)

   403

                    for varlist in resource.getglobalVars():

   404

                        for variable in varlist.getvariable():

   405

                            vartype_content = variable.gettype().getcontent()

   406

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

   407

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

   408

                                if var_infos is not None:

   409

                                    resource_infos["values"].append(var_infos)

   410

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

   411

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

   412

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

   413

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

   414

                            else:

   415

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

   416

                                                                 "elmt_type" : vartype_content["name"], 

   417

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

   418

                    config_infos["values"].append(resource_infos)

   419

                for varlist in config.getglobalVars():

   420

                    for variable in varlist.getvariable():

   421

                        vartype_content = variable.gettype().getcontent()

   422

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

   423

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

   424

                            if var_infos is not None:

   425

                                config_infos["values"].append(var_infos)

   426

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

   427

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

   428

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

   429

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

   430

                        else:

   431

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

   432

                                                           "elmt_type" : vartype_content["name"], 

   433

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

   434

                infos["values"].append(config_infos)

   435

            return infos

   436

        return None

   437

   438

    # Return pou topology informations

   439

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

   440

        project = self.GetProject(debug)

   441

        if project is not None:

   442

            pou = project.getpou(type)

   443

            if pou is not None:

   444

                pou_type = pou.getpouType()

   445

                if pou_type == "function":

   446

                    return None

   447

                elif pou_type == "program":

   448

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

   449

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

   450

                else:

   451

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

   452

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

   453

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

   454

                    for transition in pou.gettransitionList():

   455

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

   456

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

   457

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

   458

                            "values" : []})

   459

                    for action in pou.getactionList():

   460

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

   461

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

   462

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

   463

                            "values" : []})

   464

                if pou.interface:

   465

                    # Extract variables from every varLists

   466

                    for type, varlist in pou.getvars():

   467

                        infos = VAR_CLASS_INFOS.get(type, None)

   468

                        if infos is not None:

   469

                            current_var_class = infos[1]

   470

                        else:

   471

                            current_var_class = ITEM_VAR_LOCAL

   472

                        for variable in varlist.getvariable():

   473

                            vartype_content = variable.gettype().getcontent()

   474

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

   475

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

   476

                                if var_infos is not None:

   477

                                    pou_infos["values"].append(var_infos)

   478

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

   479

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

   480

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

   481

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

   482

                            else:

   483

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

   484

                                                            "elmt_type" : vartype_content["name"], 

   485

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

   486

                return pou_infos

   487

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

   488

            if block_infos is not None:

   489

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

   490

                    return None

   491

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

   492

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

   493

                else:

   494

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

   495

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

   496

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

   497

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

   498