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

    32

from plcopen import plcopen

    33

from plcopen.structures import *

    34

from graphics.GraphicCommons import *

    35

from PLCGenerator import *

    36

    37

duration_model = re.compile("(?:([0-9]{1,2})h)?(?:([0-9]{1,2})m(?!s))?(?:([0-9]{1,2})s)?(?:([0-9]{1,3}(?:\.[0-9]*)?)ms)?")

    38

    39

ITEMS_EDITABLE = [ITEM_PROJECT,

    40

                  ITEM_POU,

    41

                  ITEM_VARIABLE,

    42

                  ITEM_TRANSITION,

    43

                  ITEM_ACTION,

    44

                  ITEM_CONFIGURATION,

    45

                  ITEM_RESOURCE,

    46

                  ITEM_DATATYPE

    47

                 ] = range(8)

    48

    49

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    50

                    ITEM_FUNCTION,

    51

                    ITEM_FUNCTIONBLOCK,

    52

                    ITEM_PROGRAM,

    53

                    ITEM_TRANSITIONS,

    54

                    ITEM_ACTIONS,

    55

                    ITEM_CONFIGURATIONS,

    56

                    ITEM_RESOURCES,

    57

                    ITEM_PROPERTIES

    58

                   ] = range(8, 17)

    59

    60

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    61

                  ITEM_VAR_GLOBAL,

    62

                  ITEM_VAR_EXTERNAL,

    63

                  ITEM_VAR_TEMP,

    64

                  ITEM_VAR_INPUT,

    65

                  ITEM_VAR_OUTPUT,

    66

                  ITEM_VAR_INOUT

    67

                 ] = range(17, 24)

    68

    69

VAR_CLASS_INFOS = {"Local" :    (plcopen.interface_localVars,    ITEM_VAR_LOCAL),

    70

                   "Global" :   (plcopen.interface_globalVars,   ITEM_VAR_GLOBAL),

    71

                   "External" : (plcopen.interface_externalVars, ITEM_VAR_EXTERNAL),

    72

                   "Temp" :     (plcopen.interface_tempVars,     ITEM_VAR_TEMP),

    73

                   "Input" :    (plcopen.interface_inputVars,    ITEM_VAR_INPUT),

    74

                   "Output" :   (plcopen.interface_outputVars,   ITEM_VAR_OUTPUT),

    75

                   "InOut" :    (plcopen.interface_inOutVars,    ITEM_VAR_INOUT)

    76

                  }

    77

    78

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 = []

   215

   216

    def GetQualifierTypes(self):

   217

        return plcopen.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 = plcopen.project()

   237

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

   238

        self.Project.setfileHeader(properties)

   239

        self.Project.setcontentHeader(properties)

   240

        self.SetFilePath("")

   241

        # Initialize the project buffer

   242

        self.CreateProjectBuffer(False)

   243

        self.ProgramChunks = []

   244

        self.ProgramOffset = 0

   245

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

   246

        self.CurrentCompiledProject = None

   247

        self.Buffering = False

   248

   249

    # Return project data type names

   250

    def GetProjectDataTypeNames(self, debug = False):

   251

        project = self.GetProject(debug)

   252

        if project is not None:

   253

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

   254

        return []

   255

   256

    # Return project pou names

   257

    def GetProjectPouNames(self, debug = False):

   258

        project = self.GetProject(debug)

   259

        if project is not None:

   260

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

   261

        return []

   262

   263

    # Return project pou names

   264

    def GetProjectConfigNames(self, debug = False):

   265

        project = self.GetProject(debug)

   266

        if project is not None:

   267

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

   268

        return []

   269

   270

    # Return project pou variable names

   271

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

   272

        variables = []

   273

        project = self.GetProject(debug)

   274

        if project is not None:

   275

            for pou in project.getpous():

   276

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

   277

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

   278

                    for transition in pou.gettransitionList():

   279

                        variables.append(transition.getname())

   280

                    for action in pou.getactionList():

   281

                        variables.append(action.getname())

   282

        return variables

   283

   284

    # Return file path if project is an open file

   285

    def GetFilePath(self):

   286

        return self.FilePath

   287

   288

    # Return file path if project is an open file

   289

    def GetProgramFilePath(self):

   290

        return self.ProgramFilePath

   291

   292

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

   293

    def GetFilename(self):

   294

        if self.Project is not None:

   295

            if self.ProjectIsSaved():

   296

                return self.FileName

   297

            else:

   298

                return "~%s~"%self.FileName

   299

        return ""

   300

   301

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

   302

    def SetFilePath(self, filepath):

   303

        self.FilePath = filepath

   304

        if filepath == "":

   305

            self.LastNewIndex += 1

   306

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

   307

        else:

   308

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

   309

   310

    # Change project properties

   311

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

   312

        if self.Project is not None:

   313

            if name is not None:

   314

                self.Project.setname(name)

   315

            if properties is not None:

   316

                self.Project.setfileHeader(properties)

   317

                self.Project.setcontentHeader(properties)

   318

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

   319

                self.BufferProject()

   320

   321

    # Return project name

   322

    def GetProjectName(self, debug=False):

   323

        project = self.GetProject(debug)

   324

        if project is not None:

   325

            return project.getname()

   326

        return None

   327

   328

    # Return project properties

   329

    def GetProjectProperties(self, debug = False):

   330

        project = self.GetProject(debug)

   331

        if project is not None:

   332

            properties = project.getfileHeader()

   333

            properties.update(project.getcontentHeader())

   334

            return properties

   335

        return None

   336

   337

    # Return project informations

   338

    def GetProjectInfos(self, debug = False):

   339

        project = self.GetProject(debug)

   340

        if project is not None:

   341

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

   342

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

   343

            for datatype in project.getdataTypes():

   344

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

   345

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

   346

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

   347

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

   348

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

   349

            for pou in project.getpous():

   350

                pou_type = pou.getpouType()

   351

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

   352

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

   353

                pou_values = []

   354

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

   355

                    transitions = []

   356

                    for transition in pou.gettransitionList():

   357

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

   358

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

   359

                            "values": []})

   360

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

   361

                    actions = []

   362

                    for action in pou.getactionList():

   363

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

   364

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

   365

                            "values": []})

   366

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

   367

                if pou_type in pou_types:

   368

                    pou_infos["values"] = pou_values

   369

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

   370

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

   371

            for config in project.getconfigurations():

   372

                config_name = config.getname()

   373

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

   374

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

   375

                    "values": []}

   376

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

   377

                for resource in config.getresource():

   378

                    resource_name = resource.getname()

   379

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

   380

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

   381

                        "values": []}

   382

                    resources["values"].append(resource_infos)

   383

                config_infos["values"] = [resources]

   384

                configurations["values"].append(config_infos)

   385

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

   386

                               pou_types["program"], configurations]

   387

            return infos

   388

        return None

   389

   390

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

   391

        vartype_content = variable.gettype().getcontent()

   392

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

   393

            var_type = vartype_content["value"].getname()

   394

            pou_type = None

   395

            pou = project.getpou(var_type)

   396

            if pou is not None:

   397

                pou_type = pou.getpouType()

   398

            edit = debug = pou_type is not None

   399

            if pou_type is None:

   400

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

   401

                if block_infos is not None:

   402

                    pou_type = block_infos["type"]

   403

            if pou_type is not None:

   404

                var_class = None

   405

                if pou_type == "program":

   406

                    var_class = ITEM_PROGRAM

   407

                elif pou_type != "function":

   408

                    var_class = ITEM_FUNCTIONBLOCK

   409

                if var_class is not None:

   410

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

   411

                            "type": var_type, 

   412

                            "class": var_class,

   413

                            "edit": edit,

   414

                            "debug": debug}

   415

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

   416

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

   417

                        "type": var_type, 

   418

                        "class": var_class,

   419

                        "edit": False,

   420

                        "debug": False}

   421

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

   422

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

   423

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

   424

                    "class": var_class,

   425

                    "edit": False,

   426

                    "debug": True}

   427

        else:

   428

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

   429

                    "type": vartype_content["name"], 

   430

                    "class": var_class,

   431

                    "edit": False,

   432

                    "debug": True}

   433

        return None

   434

   435

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

   436

        vars = []

   437

        pou_type = None

   438

        project = self.GetProject(debug)

   439

        if project is not None:

   440

            words = tagname.split("::")

   441

            if words[0] == "P":

   442

                pou = project.getpou(words[1])

   443

                if pou is not None:

   444

                    pou_type = pou.getpouType()

   445

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

   446

                        pou.interface is not None):

   447

                        # Extract variables from every varLists

   448

                        for varlist_type, varlist in pou.getvars():

   449

                            var_infos = VAR_CLASS_INFOS.get(varlist_type, None)

   450

                            if var_infos is not None:

   451

                                var_class = var_infos[1]

   452

                            else:

   453

                                var_class = ITEM_VAR_LOCAL

   454

                            for variable in varlist.getvariable():

   455

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

   456

                                if var_infos is not None:

   457

                                    vars.append(var_infos)

   458

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

   459

                            for transition in pou.gettransitionList():

   460

                                vars.append({

   461

                                    "name": transition.getname(),

   462

                                    "type": None, 

   463

                                    "class": ITEM_TRANSITION,

   464

                                    "edit": True,

   465

                                    "debug": True})

   466

                            for action in pou.getactionList():

   467

                                vars.append({

   468

                                    "name": action.getname(),

   469

                                    "type": None, 

   470

                                    "class": ITEM_ACTION,

   471

                                    "edit": True,

   472

                                    "debug": True})

   473

                        return {"class": POU_TYPES[pou_type],

   474

                                "type": words[1],

   475

                                "variables": vars,

   476

                                "edit": True,

   477

                                "debug": True}

   478

                else:

   479

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

   480

                    if (block_infos is not None and 

   481

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

   482

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

   483

                            vars.append({"name" : varname, 

   484

                                         "type" : vartype, 

   485

                                         "class" : ITEM_VAR_INPUT,

   486

                                         "edit": False,

   487

                                         "debug": True})

   488

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

   489

                            vars.append({"name" : varname, 

   490

                                         "type" : vartype, 

   491

                                         "class" : ITEM_VAR_OUTPUT,

   492

                                         "edit": False,

   493

                                         "debug": True})

   494

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

   495

                                "type": None,

   496

                                "variables": vars,

   497

                                "edit": False,

   498

                                "debug": False}

   499

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

   500

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

   501

                if pou_vars is not None:

   502

                    if words[0] == 'A':

   503

                        element_type = ITEM_ACTION

   504

                    elif words[0] == 'T':

   505

                        element_type = ITEM_TRANSITION

   506

                    return {"class": element_type,

   507

                            "type": None,

   508

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

   509

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

   510

                            "edit": True,

   511

                            "debug": True}

   512

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

   513

                if words[0] == 'C':

   514

                    element_type = ITEM_CONFIGURATION

   515

                    element = project.getconfiguration(words[1])

   516

                    if element is not None:

   517

                        for resource in element.getresource():

   518

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

   519

                                         "type": None,

   520

                                         "class": ITEM_RESOURCE,

   521

                                         "edit": True,

   522

                                         "debug": False})

   523

                elif words[0] == 'R':

   524

                    element_type = ITEM_RESOURCE

   525

                    element = project.getconfigurationResource(words[1], words[2])

   526

                    if element is not None:

   527

                        for task in element.gettask():