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

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

   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 properties

   316

    def GetProjectProperties(self, debug = False):

   317

        project = self.GetProject(debug)

   318

        if project is not None:

   319

            properties = project.getfileHeader()

   320

            properties.update(project.getcontentHeader())

   321

            return properties

   322

        return None

   323

   324

    # Return project informations

   325

    def GetProjectInfos(self, debug = False):

   326

        project = self.GetProject(debug)

   327

        if project is not None:

   328

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

   329

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

   330

            for datatype in project.getdataTypes():

   331

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

   332

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

   333

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

   334

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

   335

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

   336

            for pou in project.getpous():

   337

                pou_type = pou.getpouType()

   338

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

   339

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

   340

                pou_values = []

   341

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

   342

                    transitions = []

   343

                    for transition in pou.gettransitionList():

   344

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

   345

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

   346

                            "values": []})

   347

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

   348

                    actions = []

   349

                    for action in pou.getactionList():

   350

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

   351

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

   352

                            "values": []})

   353

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

   354

                if pou_type in pou_types:

   355

                    pou_infos["values"] = pou_values

   356

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

   357

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

   358

            for config in project.getconfigurations():

   359

                config_name = config.getname()

   360

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

   361

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

   362

                    "values": []}

   363

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

   364

                for resource in config.getresource():

   365

                    resource_name = resource.getname()

   366

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

   367

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

   368

                        "values": []}

   369

                    resources["values"].append(resource_infos)

   370

                config_infos["values"] = [resources]

   371

                configurations["values"].append(config_infos)

   372

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

   373

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

   374

                               pou_types["program"], configurations]

   375

            return infos

   376

        return None

   377

   378

    # Return project topology informations

   379

    def GetProjectTopology(self, debug = False):

   380

        project = self.GetProject(debug)

   381

        if project is not None:

   382

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

   383

            for config in project.getconfigurations():

   384

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

   385

                for resource in config.getresource():

   386

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

   387

                    for task in resource.gettask():

   388

                        for pou in task.getpouInstance():

   389

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

   390

                            if instance_infos is not None:

   391

                                resource_infos["values"].append(instance_infos)

   392

                    for pou in resource.getpouInstance():

   393

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

   394

                        if instance_infos is not None:

   395

                            resource_infos["values"].append(instance_infos)

   396

                    for varlist in resource.getglobalVars():

   397

                        for variable in varlist.getvariable():

   398

                            vartype_content = variable.gettype().getcontent()

   399

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

   400

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

   401

                                if var_infos is not None:

   402

                                    resource_infos["values"].append(var_infos)

   403

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

   404

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

   405

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

   406

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

   407

                            else:

   408

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

   409

                                                                 "elmt_type" : vartype_content["name"], 

   410

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

   411

                    config_infos["values"].append(resource_infos)

   412

                for varlist in config.getglobalVars():

   413

                    for variable in varlist.getvariable():

   414

                        vartype_content = variable.gettype().getcontent()

   415

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

   416

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

   417

                            if var_infos is not None:

   418

                                config_infos["values"].append(var_infos)

   419

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

   420

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

   421

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

   422

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

   423

                        else:

   424

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

   425

                                                           "elmt_type" : vartype_content["name"], 

   426

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

   427

                infos["values"].append(config_infos)

   428

            return infos

   429

        return None

   430

   431

    # Return pou topology informations

   432

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

   433

        project = self.GetProject(debug)

   434

        if project is not None:

   435

            pou = project.getpou(type)

   436

            if pou is not None:

   437

                pou_type = pou.getpouType()

   438

                if pou_type == "function":

   439

                    return None

   440

                elif pou_type == "program":

   441

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

   442

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

   443

                else:

   444

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

   445

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

   446

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

   447

                    for transition in pou.gettransitionList():

   448

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

   449

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

   450

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

   451

                            "values" : []})

   452

                    for action in pou.getactionList():

   453

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

   454

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

   455

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

   456

                            "values" : []})

   457

                if pou.interface:

   458

                    # Extract variables from every varLists

   459

                    for type, varlist in pou.getvars():

   460

                        infos = VAR_CLASS_INFOS.get(type, None)

   461

                        if infos is not None:

   462

                            current_var_class = infos[1]

   463

                        else:

   464

                            current_var_class = ITEM_VAR_LOCAL

   465

                        for variable in varlist.getvariable():

   466

                            vartype_content = variable.gettype().getcontent()

   467

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

   468

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

   469

                                if var_infos is not None:

   470

                                    pou_infos["values"].append(var_infos)

   471

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

   472

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

   473

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

   474

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

   475

                            else:

   476

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

   477

                                                            "elmt_type" : vartype_content["name"], 

   478

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

   479

                return pou_infos

   480

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

   481

            if block_infos is not None:

   482

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

   483

                    return None

   484

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

   485

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

   486

                else:

   487

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

   488

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

   489

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

   490

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

   491

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

   492

                return pou_infos

   493

   494

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

   495

                if global_var:

   496

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

   497

                else: