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

from copy import deepcopy

    28

import os,sys,re

    29

import datetime

    30

from time import localtime

    31

    32

from plcopen import*

    33

from graphics.GraphicCommons import *

    34

from PLCGenerator import *

    35

    36

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)?")

    37

    38

ITEMS_EDITABLE = [ITEM_PROJECT,

    39

                  ITEM_POU,

    40

                  ITEM_VARIABLE,

    41

                  ITEM_TRANSITION,

    42

                  ITEM_ACTION,

    43

                  ITEM_CONFIGURATION,

    44

                  ITEM_RESOURCE,

    45

                  ITEM_DATATYPE

    46

                 ] = range(8)

    47

    48

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    49

                    ITEM_FUNCTION,

    50

                    ITEM_FUNCTIONBLOCK,

    51

                    ITEM_PROGRAM,

    52

                    ITEM_TRANSITIONS,

    53

                    ITEM_ACTIONS,

    54

                    ITEM_CONFIGURATIONS,

    55

                    ITEM_RESOURCES,

    56

                    ITEM_PROPERTIES

    57

                   ] = range(8, 17)

    58

    59

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    60

                  ITEM_VAR_GLOBAL,

    61

                  ITEM_VAR_EXTERNAL,

    62

                  ITEM_VAR_TEMP,

    63

                  ITEM_VAR_INPUT,

    64

                  ITEM_VAR_OUTPUT,

    65

                  ITEM_VAR_INOUT

    66

                 ] = range(17, 24)

    67

    68

VAR_CLASS_INFOS = {

    69

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

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

    77

POU_TYPES = {"program": ITEM_PROGRAM,

    78

             "functionBlock": ITEM_FUNCTIONBLOCK,

    79

             "function": ITEM_FUNCTION,

    80

            }

    81

    82

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    83

                   LOCATION_MODULE,

    84

                   LOCATION_GROUP,

    85

                   LOCATION_VAR_INPUT,

    86

                   LOCATION_VAR_OUTPUT,

    87

                   LOCATION_VAR_MEMORY] = range(6)

    88

    89

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

    90

    91

def GetUneditableNames():

    92

    _ = lambda x:x

    93

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

    94

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

    95

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

    96

UNEDITABLE_NAMES = GetUneditableNames()

    97

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS, 

    98

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS, 

    99

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   100

   101

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

   102

#                         Undo Buffer for PLCOpenEditor

   103

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

   104

   105

# Length of the buffer

   106

UNDO_BUFFER_LENGTH = 20

   107

   108

"""

   109

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

   110

"""

   111

class UndoBuffer:

   112

   113

    # Constructor initialising buffer

   114

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

   115

        self.Buffer = []

   116

        self.CurrentIndex = -1

   117

        self.MinIndex = -1

   118

        self.MaxIndex = -1

   119

        # if current state is defined

   120

        if currentstate:

   121

            self.CurrentIndex = 0

   122

            self.MinIndex = 0

   123

            self.MaxIndex = 0

   124

        # Initialising buffer with currentstate at the first place

   125

        for i in xrange(UNDO_BUFFER_LENGTH):

   126

            if i == 0:

   127

                self.Buffer.append(currentstate)

   128

            else:

   129

                self.Buffer.append(None)

   130

        # Initialising index of state saved

   131

        if issaved:

   132

            self.LastSave = 0

   133

        else:

   134

            self.LastSave = -1

   135

   136

    # Add a new state in buffer

   137

    def Buffering(self, currentstate):

   138

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

   139

        self.Buffer[self.CurrentIndex] = currentstate

   140

        # Actualising buffer limits

   141

        self.MaxIndex = self.CurrentIndex

   142

        if self.MinIndex == self.CurrentIndex:

   143

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

   144

            if self.LastSave == self.MinIndex:

   145

                self.LastSave = -1

   146

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

   147

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

   148

   149

    # Return current state of buffer

   150

    def Current(self):

   151

        return self.Buffer[self.CurrentIndex]

   152

   153

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

   154

    def Previous(self):

   155

        if self.CurrentIndex != self.MinIndex:

   156

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

   157

            return self.Buffer[self.CurrentIndex]

   158

        return None

   159

   160

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

   161

    def Next(self):

   162

        if self.CurrentIndex != self.MaxIndex:

   163

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

   164

            return self.Buffer[self.CurrentIndex]

   165

        return None

   166

   167

    # Return True if current state is the first in buffer

   168

    def IsFirst(self):

   169

        return self.CurrentIndex == self.MinIndex

   170

   171

    # Return True if current state is the last in buffer

   172

    def IsLast(self):

   173

        return self.CurrentIndex == self.MaxIndex

   174

   175

    # Note that current state is saved

   176

    def CurrentSaved(self):

   177

        self.LastSave = self.CurrentIndex

   178

   179

    # Return True if current state is saved

   180

    def IsCurrentSaved(self):

   181

        return self.LastSave == self.CurrentIndex

   182

   183

   184

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

   185

#                           Controler for PLCOpenEditor

   186

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

   187

   188

"""

   189

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

   190

"""

   191

class PLCControler:

   192

   193

    # Create a new PLCControler

   194

    def __init__(self):

   195

        self.LastNewIndex = 0

   196

        self.Reset()

   197

   198

    # Reset PLCControler internal variables

   199

    def Reset(self):

   200

        self.Project = None

   201

        self.ProjectBufferEnabled = True

   202

        self.ProjectBuffer = None

   203

        self.ProjectSaved = True

   204

        self.Buffering = False

   205

        self.FilePath = ""

   206

        self.FileName = ""

   207

        self.ProgramChunks = []

   208

        self.ProgramOffset = 0

   209

        self.NextCompiledProject = None

   210

        self.CurrentCompiledProject = None

   211

        self.ConfNodeTypes = []

   212

        self.TotalTypesDict = StdBlckDct.copy()

   213

        self.TotalTypes = StdBlckLst[:]

   214

        self.ProgramFilePath = ""

   215

   216

    def GetQualifierTypes(self):

   217

        return QualifierList

   218

   219

    def GetProject(self, debug = False):

   220

        if debug and self.CurrentCompiledProject is not None:

   221

            return self.CurrentCompiledProject

   222

        else:

   223

            return self.Project

   224

   225

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

   226

#                         Project management functions

   227

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

   228

   229

    # Return if a project is opened

   230

    def HasOpenedProject(self):

   231

        return self.Project is not None

   232

   233

    # Create a new project by replacing the current one

   234

    def CreateNewProject(self, properties):

   235

        # Create the project

   236

        self.Project = PLCOpenParser.CreateRoot()

   237

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

   238

        self.Project.setfileHeader(properties)

   239

        self.Project.setcontentHeader(properties)

   240

        self.SetFilePath("")

   241

   242

        # Initialize the project buffer

   243

        self.CreateProjectBuffer(False)

   244

        self.ProgramChunks = []

   245

        self.ProgramOffset = 0

   246

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

   247

        self.CurrentCompiledProject = None

   248

        self.Buffering = False

   249

   250

    # Return project data type names

   251

    def GetProjectDataTypeNames(self, debug = False):

   252

        project = self.GetProject(debug)

   253

        if project is not None:

   254

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

   255

        return []

   256

   257

    # Return project pou names

   258

    def GetProjectPouNames(self, debug = False):

   259

        project = self.GetProject(debug)

   260

        if project is not None:

   261

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

   262

        return []

   263

   264

    # Return project pou names

   265

    def GetProjectConfigNames(self, debug = False):

   266

        project = self.GetProject(debug)

   267

        if project is not None:

   268

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

   269

        return []

   270

   271

    # Return project pou variable names

   272

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

   273

        variables = []

   274

        project = self.GetProject(debug)

   275

        if project is not None:

   276

            for pou in project.getpous():

   277

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

   278

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

   279

                    for transition in pou.gettransitionList():

   280

                        variables.append(transition.getname())

   281

                    for action in pou.getactionList():

   282

                        variables.append(action.getname())

   283

        return variables

   284

   285

    # Return file path if project is an open file

   286

    def GetFilePath(self):

   287

        return self.FilePath

   288

   289

    # Return file path if project is an open file

   290

    def GetProgramFilePath(self):

   291

        return self.ProgramFilePath

   292

   293

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

   294

    def GetFilename(self):

   295

        if self.Project is not None:

   296

            if self.ProjectIsSaved():

   297

                return self.FileName

   298

            else:

   299

                return "~%s~"%self.FileName

   300

        return ""

   301

   302

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

   303

    def SetFilePath(self, filepath):

   304

        self.FilePath = filepath

   305

        if filepath == "":

   306

            self.LastNewIndex += 1

   307

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

   308

        else:

   309

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

   310

   311

    # Change project properties

   312

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

   313

        if self.Project is not None:

   314

            if name is not None:

   315

                self.Project.setname(name)

   316

            if properties is not None:

   317

                self.Project.setfileHeader(properties)

   318

                self.Project.setcontentHeader(properties)

   319

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

   320

                self.BufferProject()

   321

   322

    # Return project name

   323

    def GetProjectName(self, debug=False):

   324

        project = self.GetProject(debug)

   325

        if project is not None:

   326

            return project.getname()

   327

        return None

   328

   329

    # Return project properties

   330

    def GetProjectProperties(self, debug = False):

   331

        project = self.GetProject(debug)

   332

        if project is not None:

   333

            properties = project.getfileHeader()

   334

            properties.update(project.getcontentHeader())

   335

            return properties

   336

        return None

   337

   338

    # Return project informations

   339

    def GetProjectInfos(self, debug = False):

   340

        project = self.GetProject(debug)

   341

        if project is not None:

   342

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

   343

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

   344

            for datatype in project.getdataTypes():

   345

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

   346

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

   347

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

   348

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

   349

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

   350

            for pou in project.getpous():

   351

                pou_type = pou.getpouType()

   352

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

   353

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

   354

                pou_values = []

   355

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

   356

                    transitions = []

   357

                    for transition in pou.gettransitionList():

   358

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

   359

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

   360

                            "values": []})

   361

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

   362

                    actions = []

   363

                    for action in pou.getactionList():

   364

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

   365

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

   366

                            "values": []})

   367

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

   368

                if pou_type in pou_types:

   369

                    pou_infos["values"] = pou_values

   370

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

   371

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

   372

            for config in project.getconfigurations():

   373

                config_name = config.getname()

   374

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

   375

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

   376

                    "values": []}

   377

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

   378

                for resource in config.getresource():

   379

                    resource_name = resource.getname()

   380

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

   381

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

   382

                        "values": []}

   383

                    resources["values"].append(resource_infos)

   384

                config_infos["values"] = [resources]

   385

                configurations["values"].append(config_infos)

   386

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

   387

                               pou_types["program"], configurations]

   388

            return infos

   389

        return None

   390

   391

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

   392

        vartype_content = variable.gettype().getcontent()

   393

        vartype_content_type = vartype_content.getLocalTag()

   394

        if vartype_content_type == "derived":

   395

            var_type = vartype_content.getname()

   396

            pou_type = None

   397

            pou = project.getpou(var_type)

   398

            if pou is not None:

   399

                pou_type = pou.getpouType()

   400

            edit = debug = pou_type is not None

   401

            if pou_type is None:

   402

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

   403

                if block_infos is not None:

   404

                    pou_type = block_infos["type"]

   405

            if pou_type is not None:

   406

                var_class = None

   407

                if pou_type == "program":

   408

                    var_class = ITEM_PROGRAM

   409

                elif pou_type != "function":

   410

                    var_class = ITEM_FUNCTIONBLOCK

   411

                if var_class is not None:

   412

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

   413

                            "type": var_type, 

   414

                            "class": var_class,

   415

                            "edit": edit,

   416

                            "debug": debug}

   417

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

   418

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

   419

                        "type": var_type, 

   420

                        "class": var_class,

   421

                        "edit": False,

   422

                        "debug": False}

   423

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

   424

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

   425

                    "type": vartype_content_type.upper(), 

   426

                    "class": var_class,

   427

                    "edit": False,

   428

                    "debug": True}

   429

        else:

   430

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

   431

                    "type": vartype_content_type, 

   432

                    "class": var_class,

   433

                    "edit": False,

   434

                    "debug": True}

   435

        return None

   436

   437

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

   438

        vars = []

   439

        pou_type = None

   440

        project = self.GetProject(debug)

   441

        if project is not None:

   442

            words = tagname.split("::")

   443

            if words[0] == "P":

   444

                pou = project.getpou(words[1])

   445

                if pou is not None:

   446

                    pou_type = pou.getpouType()

   447

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

   448

                        pou.interface is not None):

   449

                        # Extract variables from every varLists

   450

                        for varlist_type, varlist in pou.getvars():

   451

                            var_infos = VAR_CLASS_INFOS.get(varlist_type, None)

   452

                            if var_infos is not None:

   453

                                var_class = var_infos[1]

   454

                            else:

   455

                                var_class = ITEM_VAR_LOCAL

   456

                            for variable in varlist.getvariable():

   457

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

   458

                                if var_infos is not None:

   459

                                    vars.append(var_infos)

   460

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

   461

                            for transition in pou.gettransitionList():

   462

                                vars.append({

   463

                                    "name": transition.getname(),

   464

                                    "type": None, 

   465

                                    "class": ITEM_TRANSITION,

   466

                                    "edit": True,

   467

                                    "debug": True})

   468

                            for action in pou.getactionList():

   469

                                vars.append({

   470

                                    "name": action.getname(),

   471

                                    "type": None, 

   472

                                    "class": ITEM_ACTION,

   473

                                    "edit": True,

   474

                                    "debug": True})

   475

                        return {"class": POU_TYPES[pou_type],

   476

                                "type": words[1],

   477

                                "variables": vars,

   478

                                "edit": True,

   479

                                "debug": True}

   480

                else:

   481

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

   482

                    if (block_infos is not None and 

   483

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

   484

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

   485

                            vars.append({"name" : varname, 

   486

                                         "type" : vartype, 

   487

                                         "class" : ITEM_VAR_INPUT,

   488

                                         "edit": False,

   489

                                         "debug": True})

   490

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

   491

                            vars.append({"name" : varname, 

   492

                                         "type" : vartype, 

   493

                                         "class" : ITEM_VAR_OUTPUT,

   494

                                         "edit": False,

   495

                                         "debug": True})

   496

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

   497

                                "type": None,

   498

                                "variables": vars,

   499

                                "edit": False,

   500

                                "debug": False}

   501

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

   502

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

   503

                if pou_vars is not None:

   504

                    if words[0] == 'A':

   505

                        element_type = ITEM_ACTION

   506

                    elif words[0] == 'T':

   507

                        element_type = ITEM_TRANSITION

   508

                    return {"class": element_type,

   509

                            "type": None,

   510

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

   511

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

   512

                            "edit": True,

   513

                            "debug": True}

   514

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

   515

                if words[0] == 'C':

   516

                    element_type = ITEM_CONFIGURATION

   517

                    element = project.getconfiguration(words[1])

   518

                    if element is not None:

   519

                        for resource in element.getresource():

   520

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

   521

                                         "type": None,

   522

                                         "class": ITEM_RESOURCE,

   523

                                         "edit": True,

   524

                                         "debug": False})