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

        # Initialize the project buffer

   244

        self.CreateProjectBuffer(False)

   245

        self.ProgramChunks = []

   246

        self.ProgramOffset = 0

   247

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

   248

        self.CurrentCompiledProject = None

   249

        self.Buffering = False

   250

   251

    # Return project data type names

   252

    def GetProjectDataTypeNames(self, debug = False):

   253

        project = self.GetProject(debug)

   254

        if project is not None:

   255

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

   256

        return []

   257

   258

    # Return project pou names

   259

    def GetProjectPouNames(self, debug = False):

   260

        project = self.GetProject(debug)

   261

        if project is not None:

   262

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

   263

        return []

   264

   265

    # Return project pou names

   266

    def GetProjectConfigNames(self, debug = False):

   267

        project = self.GetProject(debug)

   268

        if project is not None:

   269

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

   270

        return []

   271

   272

    # Return project pou variable names

   273

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

   274

        variables = []

   275

        project = self.GetProject(debug)

   276

        if project is not None:

   277

            for pou in project.getpous():

   278

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

   279

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

   280

                    for transition in pou.gettransitionList():

   281

                        variables.append(transition.getname())

   282

                    for action in pou.getactionList():

   283

                        variables.append(action.getname())

   284

        return variables

   285

   286

    # Return file path if project is an open file

   287

    def GetFilePath(self):

   288

        return self.FilePath

   289

   290

    # Return file path if project is an open file

   291

    def GetProgramFilePath(self):

   292

        return self.ProgramFilePath

   293

   294

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

   295

    def GetFilename(self):

   296

        if self.Project is not None:

   297

            if self.ProjectIsSaved():

   298

                return self.FileName

   299

            else:

   300

                return "~%s~"%self.FileName

   301

        return ""

   302

   303

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

   304

    def SetFilePath(self, filepath):

   305

        self.FilePath = filepath

   306

        if filepath == "":

   307

            self.LastNewIndex += 1

   308

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

   309

        else:

   310

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

   311

   312

    # Change project properties

   313

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

   314

        if self.Project is not None:

   315

            if name is not None:

   316

                self.Project.setname(name)

   317

            if properties is not None:

   318

                self.Project.setfileHeader(properties)

   319

                self.Project.setcontentHeader(properties)

   320

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

   321

                self.BufferProject()

   322

   323

    # Return project name

   324

    def GetProjectName(self, debug=False):

   325

        project = self.GetProject(debug)

   326

        if project is not None:

   327

            return project.getname()

   328

        return None

   329

   330

    # Return project properties

   331

    def GetProjectProperties(self, debug = False):

   332

        project = self.GetProject(debug)

   333

        if project is not None:

   334

            properties = project.getfileHeader()

   335

            properties.update(project.getcontentHeader())

   336

            return properties

   337

        return None

   338

   339

    # Return project informations

   340

    def GetProjectInfos(self, debug = False):

   341

        project = self.GetProject(debug)

   342

        if project is not None:

   343

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

   344

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

   345

            for datatype in project.getdataTypes():

   346

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

   347

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

   348

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

   349

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

   350

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

   351

            for pou in project.getpous():

   352

                pou_type = pou.getpouType()

   353

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

   354

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

   355

                pou_values = []

   356

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

   357

                    transitions = []

   358

                    for transition in pou.gettransitionList():

   359

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

   360

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

   361

                            "values": []})

   362

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

   363

                    actions = []

   364

                    for action in pou.getactionList():

   365

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

   366

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

   367

                            "values": []})

   368

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

   369

                if pou_type in pou_types:

   370

                    pou_infos["values"] = pou_values

   371

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

   372

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

   373

            for config in project.getconfigurations():

   374

                config_name = config.getname()

   375

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

   376

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

   377

                    "values": []}

   378

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

   379

                for resource in config.getresource():

   380

                    resource_name = resource.getname()

   381

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

   382

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

   383

                        "values": []}

   384

                    resources["values"].append(resource_infos)

   385

                config_infos["values"] = [resources]

   386

                configurations["values"].append(config_infos)

   387

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

   388

                               pou_types["program"], configurations]

   389

            return infos

   390

        return None

   391

   392

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

   393

        vartype_content = variable.gettype().getcontent()

   394

        vartype_content_type = vartype_content.getLocalTag()

   395

        if vartype_content_type == "derived":

   396

            var_type = vartype_content.getname()

   397

            pou_type = None

   398

            pou = project.getpou(var_type)

   399

            if pou is not None:

   400

                pou_type = pou.getpouType()

   401

            edit = debug = pou_type is not None

   402

            if pou_type is None:

   403

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

   404

                if block_infos is not None:

   405

                    pou_type = block_infos["type"]

   406

            if pou_type is not None:

   407

                var_class = None

   408

                if pou_type == "program":

   409

                    var_class = ITEM_PROGRAM

   410

                elif pou_type != "function":

   411

                    var_class = ITEM_FUNCTIONBLOCK

   412

                if var_class is not None:

   413

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

   414

                            "type": var_type, 

   415

                            "class": var_class,

   416

                            "edit": edit,

   417

                            "debug": debug}

   418

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

   419

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

   420

                        "type": var_type, 

   421

                        "class": var_class,

   422

                        "edit": False,

   423

                        "debug": False}

   424

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

   425

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

   426

                    "type": vartype_content_type.upper(), 

   427

                    "class": var_class,

   428

                    "edit": False,

   429

                    "debug": True}

   430

        else:

   431

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

   432

                    "type": vartype_content_type, 

   433

                    "class": var_class,

   434

                    "edit": False,

   435

                    "debug": True}

   436

        return None

   437

   438

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

   439

        vars = []

   440

        pou_type = None

   441

        project = self.GetProject(debug)

   442

        if project is not None:

   443

            words = tagname.split("::")

   444

            if words[0] == "P":

   445

                pou = project.getpou(words[1])

   446

                if pou is not None:

   447

                    pou_type = pou.getpouType()

   448

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

   449

                        pou.interface is not None):

   450

                        # Extract variables from every varLists

   451

                        for varlist_type, varlist in pou.getvars():

   452

                            var_infos = VAR_CLASS_INFOS.get(varlist_type, None)

   453

                            if var_infos is not None:

   454

                                var_class = var_infos[1]

   455

                            else:

   456

                                var_class = ITEM_VAR_LOCAL

   457

                            for variable in varlist.getvariable():

   458

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

   459

                                if var_infos is not None:

   460

                                    vars.append(var_infos)

   461

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

   462

                            for transition in pou.gettransitionList():

   463

                                vars.append({

   464

                                    "name": transition.getname(),

   465

                                    "type": None, 

   466

                                    "class": ITEM_TRANSITION,

   467

                                    "edit": True,

   468

                                    "debug": True})

   469

                            for action in pou.getactionList():

   470

                                vars.append({

   471

                                    "name": action.getname(),

   472

                                    "type": None, 

   473

                                    "class": ITEM_ACTION,

   474

                                    "edit": True,

   475

                                    "debug": True})

   476

                        return {"class": POU_TYPES[pou_type],

   477

                                "type": words[1],

   478

                                "variables": vars,

   479

                                "edit": True,

   480

                                "debug": True}

   481

                else:

   482

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

   483

                    if (block_infos is not None and 

   484

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

   485

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

   486

                            vars.append({"name" : varname, 

   487

                                         "type" : vartype, 

   488

                                         "class" : ITEM_VAR_INPUT,

   489

                                         "edit": False,

   490

                                         "debug": True})

   491

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

   492

                            vars.append({"name" : varname, 

   493

                                         "type" : vartype, 

   494

                                         "class" : ITEM_VAR_OUTPUT,

   495

                                         "edit": False,

   496

                                         "debug": True})

   497

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

   498

                                "type": None,

   499

                                "variables": vars,

   500

                                "edit": False,

   501

                                "debug": False}

   502

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

   503

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

   504

                if pou_vars is not None:

   505

                    if words[0] == 'A':

   506

                        element_type = ITEM_ACTION

   507

                    elif words[0] == 'T':

   508

                        element_type = ITEM_TRANSITION

   509

                    return {"class": element_type,

   510

                            "type": None,

   511

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

   512

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

   513

                            "edit": True,

   514

                            "debug": True}

   515

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

   516

                if words[0] == 'C':

   517

                    element_type = ITEM_CONFIGURATION

   518

                    element = project.getconfiguration(words[1])

   519

                    if element is not None:

   520

                        for resource in element.getresource():

   521

                            vars.append({"name": resource.getname(),

   522

                                         "type": None,

   523

                                         "class": ITEM_RESOURCE,

   524

                                         "edit": True,