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

from copy import deepcopy

    29

import os,sys,re

    30

import datetime

    31

from time import localtime

    32

    33

from plcopen 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 = {

    70

    "Local":    ("localVars",    ITEM_VAR_LOCAL),

    71

    "Global":   ("globalVars",   ITEM_VAR_GLOBAL),

    72

    "External": ("externalVars", ITEM_VAR_EXTERNAL),

    73

    "Temp":     ("tempVars",     ITEM_VAR_TEMP),

    74

    "Input":    ("inputVars",    ITEM_VAR_INPUT),

    75

    "Output":   ("outputVars",   ITEM_VAR_OUTPUT),

    76

    "InOut":    ("inOutVars",    ITEM_VAR_INOUT)}

    77

    78

POU_TYPES = {"program": ITEM_PROGRAM,

    79

             "functionBlock": ITEM_FUNCTIONBLOCK,

    80

             "function": ITEM_FUNCTION,

    81

            }

    82

    83

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    84

                   LOCATION_MODULE,

    85

                   LOCATION_GROUP,

    86

                   LOCATION_VAR_INPUT,

    87

                   LOCATION_VAR_OUTPUT,

    88

                   LOCATION_VAR_MEMORY] = range(6)

    89

    90

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

    91

    92

def GetUneditableNames():

    93

    _ = lambda x:x

    94

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

    95

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

    96

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

    97

UNEDITABLE_NAMES = GetUneditableNames()

    98

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS, 

    99

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS, 

   100

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   101

   102

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

   103

#                         Undo Buffer for PLCOpenEditor

   104

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

   105

   106

# Length of the buffer

   107

UNDO_BUFFER_LENGTH = 20

   108

   109

"""

   110

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

   111

"""

   112

class UndoBuffer:

   113

   114

    # Constructor initialising buffer

   115

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

   116

        self.Buffer = []

   117

        self.CurrentIndex = -1

   118

        self.MinIndex = -1

   119

        self.MaxIndex = -1

   120

        # if current state is defined

   121

        if currentstate:

   122

            self.CurrentIndex = 0

   123

            self.MinIndex = 0

   124

            self.MaxIndex = 0

   125

        # Initialising buffer with currentstate at the first place

   126

        for i in xrange(UNDO_BUFFER_LENGTH):

   127

            if i == 0:

   128

                self.Buffer.append(currentstate)

   129

            else:

   130

                self.Buffer.append(None)

   131

        # Initialising index of state saved

   132

        if issaved:

   133

            self.LastSave = 0

   134

        else:

   135

            self.LastSave = -1

   136

   137

    # Add a new state in buffer

   138

    def Buffering(self, currentstate):

   139

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

   140

        self.Buffer[self.CurrentIndex] = currentstate

   141

        # Actualising buffer limits

   142

        self.MaxIndex = self.CurrentIndex

   143

        if self.MinIndex == self.CurrentIndex:

   144

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

   145

            if self.LastSave == self.MinIndex:

   146

                self.LastSave = -1

   147

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

   148

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

   149

   150

    # Return current state of buffer

   151

    def Current(self):

   152

        return self.Buffer[self.CurrentIndex]

   153

   154

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

   155

    def Previous(self):

   156

        if self.CurrentIndex != self.MinIndex:

   157

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

   158

            return self.Buffer[self.CurrentIndex]

   159

        return None

   160

   161

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

   162

    def Next(self):

   163

        if self.CurrentIndex != self.MaxIndex:

   164

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

   165

            return self.Buffer[self.CurrentIndex]

   166

        return None

   167

   168

    # Return True if current state is the first in buffer

   169

    def IsFirst(self):

   170

        return self.CurrentIndex == self.MinIndex

   171

   172

    # Return True if current state is the last in buffer

   173

    def IsLast(self):

   174

        return self.CurrentIndex == self.MaxIndex

   175

   176

    # Note that current state is saved

   177

    def CurrentSaved(self):

   178

        self.LastSave = self.CurrentIndex

   179

   180

    # Return True if current state is saved

   181

    def IsCurrentSaved(self):

   182

        return self.LastSave == self.CurrentIndex

   183

   184

   185

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

   186

#                           Controler for PLCOpenEditor

   187

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

   188

   189

"""

   190

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

   191

"""

   192

class PLCControler:

   193

   194

    # Create a new PLCControler

   195

    def __init__(self):

   196

        self.LastNewIndex = 0

   197

        self.Reset()

   198

   199

    # Reset PLCControler internal variables

   200

    def Reset(self):

   201

        self.Project = None

   202

        self.ProjectBufferEnabled = True

   203

        self.ProjectBuffer = None

   204

        self.ProjectSaved = True

   205

        self.Buffering = False

   206

        self.FilePath = ""

   207

        self.FileName = ""

   208

        self.ProgramChunks = []

   209

        self.ProgramOffset = 0

   210

        self.NextCompiledProject = None

   211

        self.CurrentCompiledProject = None

   212

        self.ConfNodeTypes = []

   213

        self.TotalTypesDict = StdBlckDct.copy()

   214

        self.TotalTypes = StdBlckLst[:]

   215

        self.ProgramFilePath = ""

   216

   217

    def GetQualifierTypes(self):

   218

        return QualifierList

   219

   220

    def GetProject(self, debug = False):

   221

        if debug and self.CurrentCompiledProject is not None:

   222

            return self.CurrentCompiledProject

   223

        else:

   224

            return self.Project

   225

   226

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

   227

#                         Project management functions

   228

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

   229

   230

    # Return if a project is opened

   231

    def HasOpenedProject(self):

   232

        return self.Project is not None

   233

   234

    # Create a new project by replacing the current one

   235

    def CreateNewProject(self, properties):

   236

        # Create the project

   237

        self.Project = PLCOpenParser.CreateRoot()

   238

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

   239

        self.Project.setfileHeader(properties)

   240

        self.Project.setcontentHeader(properties)

   241

        self.SetFilePath("")

   242

   243

        ## To remove when project buffering ready

   244

        self.ProjectBufferEnabled = False

   245

   246

        # Initialize the project buffer

   247

        self.CreateProjectBuffer(False)

   248

        self.ProgramChunks = []

   249

        self.ProgramOffset = 0

   250

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

   251

        self.CurrentCompiledProject = None

   252

        self.Buffering = False

   253

   254

    # Return project data type names

   255

    def GetProjectDataTypeNames(self, debug = False):

   256

        project = self.GetProject(debug)

   257

        if project is not None:

   258

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

   259

        return []

   260

   261

    # Return project pou names

   262

    def GetProjectPouNames(self, debug = False):

   263

        project = self.GetProject(debug)

   264

        if project is not None:

   265

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

   266

        return []

   267

   268

    # Return project pou names

   269

    def GetProjectConfigNames(self, debug = False):

   270

        project = self.GetProject(debug)

   271

        if project is not None:

   272

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

   273

        return []

   274

   275

    # Return project pou variable names

   276

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

   277

        variables = []

   278

        project = self.GetProject(debug)

   279

        if project is not None:

   280

            for pou in project.getpous():

   281

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

   282

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

   283

                    for transition in pou.gettransitionList():

   284

                        variables.append(transition.getname())

   285

                    for action in pou.getactionList():

   286

                        variables.append(action.getname())

   287

        return variables

   288

   289

    # Return file path if project is an open file

   290

    def GetFilePath(self):

   291

        return self.FilePath

   292

   293

    # Return file path if project is an open file

   294

    def GetProgramFilePath(self):

   295

        return self.ProgramFilePath

   296

   297

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

   298

    def GetFilename(self):

   299

        if self.Project is not None:

   300

            if self.ProjectIsSaved():

   301

                return self.FileName

   302

            else:

   303

                return "~%s~"%self.FileName

   304

        return ""

   305

   306

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

   307

    def SetFilePath(self, filepath):

   308

        self.FilePath = filepath

   309

        if filepath == "":

   310

            self.LastNewIndex += 1

   311

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

   312

        else:

   313

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

   314

   315

    # Change project properties

   316

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

   317

        if self.Project is not None:

   318

            if name is not None:

   319

                self.Project.setname(name)

   320

            if properties is not None:

   321

                self.Project.setfileHeader(properties)

   322

                self.Project.setcontentHeader(properties)

   323

            if buffer and (name is not None or properties is not None):

   324

                self.BufferProject()

   325

   326

    # Return project name

   327

    def GetProjectName(self, debug=False):

   328

        project = self.GetProject(debug)

   329

        if project is not None:

   330

            return project.getname()

   331

        return None

   332

   333

    # Return project properties

   334

    def GetProjectProperties(self, debug = False):

   335

        project = self.GetProject(debug)

   336

        if project is not None:

   337

            properties = project.getfileHeader()

   338

            properties.update(project.getcontentHeader())

   339

            return properties

   340

        return None

   341

   342

    # Return project informations

   343

    def GetProjectInfos(self, debug = False):

   344

        project = self.GetProject(debug)

   345

        if project is not None:

   346

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

   347

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

   348

            for datatype in project.getdataTypes():

   349

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

   350

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

   351

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

   352

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

   353

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

   354

            for pou in project.getpous():

   355

                pou_type = pou.getpouType()

   356

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

   357

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

   358

                pou_values = []

   359

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

   360

                    transitions = []

   361

                    for transition in pou.gettransitionList():

   362

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

   363

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

   364

                            "values": []})

   365

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

   366

                    actions = []

   367

                    for action in pou.getactionList():

   368

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

   369

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

   370

                            "values": []})

   371

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

   372

                if pou_type in pou_types:

   373

                    pou_infos["values"] = pou_values

   374

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

   375

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

   376

            for config in project.getconfigurations():

   377

                config_name = config.getname()

   378

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

   379

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

   380

                    "values": []}

   381

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

   382

                for resource in config.getresource():

   383

                    resource_name = resource.getname()

   384

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

   385

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

   386

                        "values": []}

   387

                    resources["values"].append(resource_infos)

   388

                config_infos["values"] = [resources]

   389

                configurations["values"].append(config_infos)

   390

            infos["values"] = [datatypes, pou_types["function"], pou_types["functionBlock"], 

   391

                               pou_types["program"], configurations]

   392

            return infos

   393

        return None

   394

   395

    def GetPouVariableInfos(self, project, variable, var_class, debug=False):

   396

        vartype_content = variable.gettype().getcontent()

   397

        vartype_content_type = vartype_content.getLocalTag()

   398

        if vartype_content_type == "derived":

   399

            var_type = vartype_content.getname()

   400

            pou_type = None

   401

            pou = project.getpou(var_type)

   402

            if pou is not None:

   403

                pou_type = pou.getpouType()

   404

            edit = debug = pou_type is not None

   405

            if pou_type is None:

   406

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

   407

                if block_infos is not None:

   408

                    pou_type = block_infos["type"]

   409

            if pou_type is not None:

   410

                var_class = None

   411

                if pou_type == "program":

   412

                    var_class = ITEM_PROGRAM

   413

                elif pou_type != "function":

   414

                    var_class = ITEM_FUNCTIONBLOCK

   415

                if var_class is not None:

   416

                    return {"name": variable.getname(), 

   417

                            "type": var_type, 

   418

                            "class": var_class,

   419

                            "edit": edit,

   420

                            "debug": debug}

   421

            elif var_type in self.GetDataTypes(debug = debug):

   422

                return {"name": variable.getname(), 

   423

                        "type": var_type, 

   424

                        "class": var_class,

   425

                        "edit": False,

   426

                        "debug": False}

   427

        elif vartype_content_type in ["string", "wstring"]:

   428

            return {"name": variable.getname(), 

   429

                    "type": vartype_content_type.upper(), 

   430

                    "class": var_class,

   431

                    "edit": False,

   432

                    "debug": True}

   433

        else:

   434

            return {"name": variable.getname(),

   435

                    "type": vartype_content_type, 

   436

                    "class": var_class,

   437

                    "edit": False,

   438

                    "debug": True}

   439

        return None

   440

   441

    def GetPouVariables(self, tagname, debug = False):

   442

        vars = []

   443

        pou_type = None

   444

        project = self.GetProject(debug)

   445

        if project is not None:

   446

            words = tagname.split("::")

   447

            if words[0] == "P":

   448

                pou = project.getpou(words[1])

   449

                if pou is not None:

   450

                    pou_type = pou.getpouType()

   451

                    if (pou_type in ["program", "functionBlock"] and 

   452

                        pou.interface is not None):

   453

                        # Extract variables from every varLists

   454

                        for varlist_type, varlist in pou.getvars():

   455

                            var_infos = VAR_CLASS_INFOS.get(varlist_type, None)

   456

                            if var_infos is not None:

   457

                                var_class = var_infos[1]

   458

                            else:

   459

                                var_class = ITEM_VAR_LOCAL

   460

                            for variable in varlist.getvariable():

   461

                                var_infos = self.GetPouVariableInfos(project, variable, var_class, debug)

   462

                                if var_infos is not None:

   463

                                    vars.append(var_infos)

   464

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

   465

                            for transition in pou.gettransitionList():

   466

                                vars.append({

   467

                                    "name": transition.getname(),

   468

                                    "type": None, 

   469

                                    "class": ITEM_TRANSITION,

   470

                                    "edit": True,

   471

                                    "debug": True})

   472

                            for action in pou.getactionList():

   473

                                vars.append({

   474

                                    "name": action.getname(),

   475

                                    "type": None, 

   476

                                    "class": ITEM_ACTION,

   477

                                    "edit": True,

   478

                                    "debug": True})

   479

                        return {"class": POU_TYPES[pou_type],

   480

                                "type": words[1],

   481

                                "variables": vars,

   482

                                "edit": True,

   483

                                "debug": True}

   484

                else:

   485

                    block_infos = self.GetBlockType(words[1], debug = debug)

   486

                    if (block_infos is not None and 

   487

                        block_infos["type"] in ["program", "functionBlock"]):

   488

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

   489

                            vars.append({"name" : varname, 

   490

                                         "type" : vartype, 

   491

                                         "class" : ITEM_VAR_INPUT,

   492

                                         "edit": False,

   493

                                         "debug": True})

   494

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

   495

                            vars.append({"name" : varname, 

   496

                                         "type" : vartype, 

   497

                                         "class" : ITEM_VAR_OUTPUT,

   498

                                         "edit": False,

   499

                                         "debug": True})

   500

                        return {"class": POU_TYPES[block_infos["type"]],

   501

                                "type": None,

   502

                                "variables": vars,

   503

                                "edit": False,

   504

                                "debug": False}

   505

            elif words[0] in ['A', 'T']:

   506

                pou_vars = self.GetPouVariables(self.ComputePouName(words[1]), debug)

   507

                if pou_vars is not None:

   508

                    if words[0] == 'A':

   509

                        element_type = ITEM_ACTION

   510

                    elif words[0] == 'T':

   511

                        element_type = ITEM_TRANSITION

   512

                    return {"class": element_type,

   513

                            "type": None,

   514

                            "variables": [var for var in pou_vars["variables"] 

   515

                                          if var["class"] not in [ITEM_ACTION, ITEM_TRANSITION]],

   516

                            "edit": True,

   517

                            "debug": True}

   518

            elif words[0] in ['C', 'R']:

   519

                if words[0] == 'C':

   520

                    element_type = ITEM_CONFIGURATION

   521

                    element = project.getconfiguration(words[1])

   522

                    if element is not None:

   523

                        for resource in element.getresource():

   524