1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library is distributed in the hope that it will be useful,

    17

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

from xml.dom import minidom

    26

from types import StringType, UnicodeType, TupleType

    27

import cPickle

    28

import os,sys,re

    29

import datetime

    30

from time import localtime

    31

    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

    79

    80

POU_TYPES = {"program": ITEM_PROGRAM,

    81

             "functionBlock": ITEM_FUNCTIONBLOCK,

    82

             "function": ITEM_FUNCTION,

    83

            }

    84

    85

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    86

                   LOCATION_MODULE,

    87

                   LOCATION_GROUP,

    88

                   LOCATION_VAR_INPUT,

    89

                   LOCATION_VAR_OUTPUT,

    90

                   LOCATION_VAR_MEMORY] = range(6)

    91

    92

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

    93

    94

def GetUneditableNames():

    95

    _ = lambda x:x

    96

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

    97

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

    98

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

    99

UNEDITABLE_NAMES = GetUneditableNames()

   100

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS, 

   101

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS, 

   102

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   103

   104

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

   105

#                         Undo Buffer for PLCOpenEditor

   106

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

   107

   108

# Length of the buffer

   109

UNDO_BUFFER_LENGTH = 20

   110

   111

"""

   112

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

   113

"""

   114

class UndoBuffer:

   115

   116

    # Constructor initialising buffer

   117

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

   118

        self.Buffer = []

   119

        self.CurrentIndex = -1

   120

        self.MinIndex = -1

   121

        self.MaxIndex = -1

   122

        # if current state is defined

   123

        if currentstate:

   124

            self.CurrentIndex = 0

   125

            self.MinIndex = 0

   126

            self.MaxIndex = 0

   127

        # Initialising buffer with currentstate at the first place

   128

        for i in xrange(UNDO_BUFFER_LENGTH):

   129

            if i == 0:

   130

                self.Buffer.append(currentstate)

   131

            else:

   132

                self.Buffer.append(None)

   133

        # Initialising index of state saved

   134

        if issaved:

   135

            self.LastSave = 0

   136

        else:

   137

            self.LastSave = -1

   138

   139

    # Add a new state in buffer

   140

    def Buffering(self, currentstate):

   141

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

   142

        self.Buffer[self.CurrentIndex] = currentstate

   143

        # Actualising buffer limits

   144

        self.MaxIndex = self.CurrentIndex

   145

        if self.MinIndex == self.CurrentIndex:

   146

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

   147

            if self.LastSave == self.MinIndex:

   148

                self.LastSave = -1

   149

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

   150

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

   151

   152

    # Return current state of buffer

   153

    def Current(self):

   154

        return self.Buffer[self.CurrentIndex]

   155

   156

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

   157

    def Previous(self):

   158

        if self.CurrentIndex != self.MinIndex:

   159

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

   160

            return self.Buffer[self.CurrentIndex]

   161

        return None

   162

   163

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

   164

    def Next(self):

   165

        if self.CurrentIndex != self.MaxIndex:

   166

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

   167

            return self.Buffer[self.CurrentIndex]

   168

        return None

   169

   170

    # Return True if current state is the first in buffer

   171

    def IsFirst(self):

   172

        return self.CurrentIndex == self.MinIndex

   173

   174

    # Return True if current state is the last in buffer

   175

    def IsLast(self):

   176

        return self.CurrentIndex == self.MaxIndex

   177

   178

    # Note that current state is saved

   179

    def CurrentSaved(self):

   180

        self.LastSave = self.CurrentIndex

   181

   182

    # Return True if current state is saved

   183

    def IsCurrentSaved(self):

   184

        return self.LastSave == self.CurrentIndex

   185

   186

   187

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

   188

#                           Controler for PLCOpenEditor

   189

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

   190

   191

"""

   192

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

   193

"""

   194

class PLCControler:

   195

   196

    # Create a new PLCControler

   197

    def __init__(self):

   198

        self.LastNewIndex = 0

   199

        self.Reset()

   200

   201

    # Reset PLCControler internal variables

   202

    def Reset(self):

   203

        self.Project = None

   204

        self.ProjectBufferEnabled = True

   205

        self.ProjectBuffer = None

   206

        self.ProjectSaved = True

   207

        self.Buffering = False

   208

        self.FilePath = ""

   209

        self.FileName = ""

   210

        self.ProgramChunks = []

   211

        self.ProgramOffset = 0

   212

        self.NextCompiledProject = None

   213

        self.CurrentCompiledProject = None

   214

        self.ConfNodeTypes = []

   215

        self.TotalTypesDict = StdBlckDct.copy()

   216

        self.TotalTypes = StdBlckLst[:]

   217

        self.ProgramFilePath = ""

   218

   219

    def GetQualifierTypes(self):

   220

        return plcopen.QualifierList

   221

   222

    def GetProject(self, debug = False):

   223

        if debug and self.CurrentCompiledProject is not None:

   224

            return self.CurrentCompiledProject

   225

        else:

   226

            return self.Project

   227

   228

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

   229

#                         Project management functions

   230

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

   231

   232

    # Return if a project is opened

   233

    def HasOpenedProject(self):

   234

        return self.Project is not None

   235

   236

    # Create a new project by replacing the current one

   237

    def CreateNewProject(self, properties):

   238

        # Create the project

   240

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

   241

        self.Project.setfileHeader(properties)

   242

        self.Project.setcontentHeader(properties)

   243

        self.SetFilePath("")

   244

        # Initialize the project buffer

   245

        self.CreateProjectBuffer(False)

   246

        self.ProgramChunks = []

   247

        self.ProgramOffset = 0

   248

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

   249

        self.CurrentCompiledProject = None

   250

        self.Buffering = False

   251

   252

    # Return project data type names

   253

    def GetProjectDataTypeNames(self, debug = False):

   254

        project = self.GetProject(debug)

   255

        if project is not None:

   256

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

   257

        return []

   258

   259

    # Return project pou names

   260

    def GetProjectPouNames(self, debug = False):

   261

        project = self.GetProject(debug)

   262

        if project is not None:

   263

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

   264

        return []

   265

   266

    # Return project pou names

   267

    def GetProjectConfigNames(self, debug = False):

   268

        project = self.GetProject(debug)

   269

        if project is not None:

   270

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

   271

        return []

   272

   273

    # Return project pou variable names

   274

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

   275

        variables = []

   276

        project = self.GetProject(debug)

   277

        if project is not None:

   278

            for pou in project.getpous():

   279

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

   280

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

   281

                    for transition in pou.gettransitionList():

   282

                        variables.append(transition.getname())

   283

                    for action in pou.getactionList():

   284

                        variables.append(action.getname())

   285

        return variables

   286

   287

    # Return file path if project is an open file

   288

    def GetFilePath(self):

   289

        return self.FilePath

   290

   291

    # Return file path if project is an open file

   292

    def GetProgramFilePath(self):

   293

        return self.ProgramFilePath

   294

   295

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

   296

    def GetFilename(self):

   297

        if self.Project is not None:

   298

            if self.ProjectIsSaved():

   299

                return self.FileName

   300

            else:

   301

                return "~%s~"%self.FileName

   302

        return ""

   303

   304

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

   305

    def SetFilePath(self, filepath):

   306

        self.FilePath = filepath

   307

        if filepath == "":

   308

            self.LastNewIndex += 1

   309

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

   310

        else:

   311

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

   312

   313

    # Change project properties

   314

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

   315

        if self.Project is not None:

   316

            if name is not None:

   317

                self.Project.setname(name)

   318

            if properties is not None:

   319

                self.Project.setfileHeader(properties)

   320

                self.Project.setcontentHeader(properties)

   321

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

   322

                self.BufferProject()

   323

   324

    # Return project name

   325

    def GetProjectName(self, debug=False):

   326

        project = self.GetProject(debug)

   327

        if project is not None:

   328

            return project.getname()

   329

        return None

   330

   331

    # Return project properties

   332

    def GetProjectProperties(self, debug = False):

   333

        project = self.GetProject(debug)

   334

        if project is not None:

   335

            properties = project.getfileHeader()

   336

            properties.update(project.getcontentHeader())

   337

            return properties

   338

        return None

   339

   340

    # Return project informations

   341

    def GetProjectInfos(self, debug = False):

   342

        project = self.GetProject(debug)

   343

        if project is not None:

   344

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

   345

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

   346

            for datatype in project.getdataTypes():

   347

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

   348

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

   349

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

   350

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

   351

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

   352

            for pou in project.getpous():

   353

                pou_type = pou.getpouType()

   354

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

   355

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

   356

                pou_values = []

   357

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

   358

                    transitions = []

   359

                    for transition in pou.gettransitionList():

   360

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

   361

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

   362

                            "values": []})

   363

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

   364

                    actions = []

   365

                    for action in pou.getactionList():

   366

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

   367

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

   368

                            "values": []})

   369

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

   370

                if pou_type in pou_types:

   371

                    pou_infos["values"] = pou_values

   372

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

   373

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

   374

            for config in project.getconfigurations():

   375

                config_name = config.getname()

   376

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

   377

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

   378

                    "values": []}

   379

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

   380

                for resource in config.getresource():

   381

                    resource_name = resource.getname()

   382

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

   383

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

   384

                        "values": []}

   385

                    resources["values"].append(resource_infos)

   386

                config_infos["values"] = [resources]

   387

                configurations["values"].append(config_infos)

   388

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

   389

                               pou_types["program"], configurations]

   390

            return infos

   391

        return None

   392

   393

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

   394

        vartype_content = variable.gettype().getcontent()

   395

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

   396

            var_type = vartype_content["value"].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["name"] in ["string", "wstring"]:

   425

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

   426

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

   427

                    "class": var_class,

   428

                    "edit": False,

   429

                    "debug": True}

   430

        else:

   431

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

   432

                    "type": vartype_content["name"], 

   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,

   525

                                         "debug": False})