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

   213

        self.ProgramFilePath = ""

   214

   215

    def GetQualifierTypes(self):

   216

        return plcopen.QualifierList

   217

   218

    def GetProject(self, debug = False):

   219

        if debug and self.CurrentCompiledProject is not None:

   220

            return self.CurrentCompiledProject

   221

        else:

   222

            return self.Project

   223

   224

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

   225

#                         Project management functions

   226

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

   227

   228

    # Return if a project is opened

   229

    def HasOpenedProject(self):

   230

        return self.Project is not None

   231

   232

    # Create a new project by replacing the current one

   233

    def CreateNewProject(self, properties):

   234

        # Create the project

   235

        self.Project = plcopen.project()

   236

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

   237

        self.Project.setfileHeader(properties)

   238

        self.Project.setcontentHeader(properties)

   239

        self.SetFilePath("")

   240

        # Initialize the project buffer

   241

        self.CreateProjectBuffer(False)

   242

        self.ProgramChunks = []

   243

        self.ProgramOffset = 0

   244

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

   245

        self.CurrentCompiledProject = None

   246

        self.Buffering = False

   247

   248

    # Return project data type names

   249

    def GetProjectDataTypeNames(self, debug = False):

   250

        project = self.GetProject(debug)

   251

        if project is not None:

   252

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

   253

        return []

   254

   255

    # Return project pou names

   256

    def GetProjectPouNames(self, debug = False):

   257

        project = self.GetProject(debug)

   258

        if project is not None:

   259

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

   260

        return []

   261

   262

    # Return project pou names

   263

    def GetProjectConfigNames(self, debug = False):

   264

        project = self.GetProject(debug)

   265

        if project is not None:

   266

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

   267

        return []

   268

   269

    # Return project pou variables

   270

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

   271

        variables = []

   272

        project = self.GetProject(debug)

   273

        if project is not None:

   274

            for pou in project.getpous():

   275

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

   276

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

   277

                    for transition in pou.gettransitionList():

   278

                        variables.append(transition.getname())

   279

                    for action in pou.getactionList():

   280

                        variables.append(action.getname())

   281

        return variables

   282

   283

    # Return file path if project is an open file

   284

    def GetFilePath(self):

   285

        return self.FilePath

   286

   287

    # Return file path if project is an open file

   288

    def GetProgramFilePath(self):

   289

        return self.ProgramFilePath

   290

   291

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

   292

    def GetFilename(self):

   293

        if self.Project is not None:

   294

            if self.ProjectIsSaved():

   295

                return self.FileName

   296

            else:

   297

                return "~%s~"%self.FileName

   298

        return ""

   299

   300

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

   301

    def SetFilePath(self, filepath):

   302

        self.FilePath = filepath

   303

        if filepath == "":

   304

            self.LastNewIndex += 1

   305

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

   306

        else:

   307

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

   308

   309

    # Change project properties

   310

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

   311

        if self.Project is not None:

   312

            if name is not None:

   313

                self.Project.setname(name)

   314

            if properties is not None:

   315

                self.Project.setfileHeader(properties)

   316

                self.Project.setcontentHeader(properties)

   317

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

   318

                self.BufferProject()

   319

   320

    # Return project name

   321

    def GetProjectName(self, debug=False):

   322

        project = self.GetProject(debug)

   323

        if project is not None:

   324

            return project.getname()

   325

        return None

   326

   327

    # Return project properties

   328

    def GetProjectProperties(self, debug = False):

   329

        project = self.GetProject(debug)

   330

        if project is not None:

   331

            properties = project.getfileHeader()

   332

            properties.update(project.getcontentHeader())

   333

            return properties

   334

        return None

   335

   336

    # Return project informations

   337

    def GetProjectInfos(self, debug = False):

   338

        project = self.GetProject(debug)

   339

        if project is not None:

   340

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

   341

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

   342

            for datatype in project.getdataTypes():

   343

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

   344

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

   345

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

   346

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

   347

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

   348

            for pou in project.getpous():

   349

                pou_type = pou.getpouType()

   350

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

   351

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

   352

                pou_values = []

   353

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

   354

                    transitions = []

   355

                    for transition in pou.gettransitionList():

   356

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

   357

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

   358

                            "values": []})

   359

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

   360

                    actions = []

   361

                    for action in pou.getactionList():

   362

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

   363

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

   364

                            "values": []})

   365

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

   366

                if pou_type in pou_types:

   367

                    pou_infos["values"] = pou_values

   368

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

   369

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

   370

            for config in project.getconfigurations():

   371

                config_name = config.getname()

   372

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

   373

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

   374

                    "values": []}

   375

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

   376

                for resource in config.getresource():

   377

                    resource_name = resource.getname()

   378

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

   379

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

   380

                        "values": []}

   381

                    resources["values"].append(resource_infos)

   382

                config_infos["values"] = [resources]

   383

                configurations["values"].append(config_infos)

   384

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

   385

                               pou_types["program"], configurations]

   386

            return infos

   387

        return None

   388

   389

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

   390

        vartype_content = variable.gettype().getcontent()

   391

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

   392

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

   393

            pou_type = None

   394

            pou = project.getpou(var_type)

   395

            if pou is not None:

   396

                pou_type = pou.getpouType()

   397

            edit = debug = pou_type is not None

   398

            if pou_type is None:

   399

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

   400

                if block_infos is not None:

   401

                    pou_type = block_infos["type"]

   402

            if pou_type is not None:

   403

                var_class = None

   404

                if pou_type == "program":

   405

                    var_class = ITEM_PROGRAM

   406

                elif pou_type != "function":

   407

                    var_class = ITEM_FUNCTIONBLOCK

   408

                if var_class is not None:

   409

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

   410

                            "type": var_type, 

   411

                            "class": var_class,

   412

                            "edit": edit,

   413

                            "debug": debug}

   414

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

   415

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

   416

                        "type": var_type, 

   417

                        "class": var_class,

   418

                        "edit": False,

   419

                        "debug": False}

   420

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

   421

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

   422

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

   423

                    "class": var_class,

   424

                    "edit": False,

   425

                    "debug": True}

   426

        else:

   427

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

   428

                    "type": vartype_content["name"], 

   429

                    "class": var_class,

   430

                    "edit": False,

   431

                    "debug": True}

   432

        return None

   433

   434

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

   435

        vars = []

   436

        pou_type = None

   437

        project = self.GetProject(debug)

   438

        if project is not None:

   439

            words = tagname.split("::")

   440

            if words[0] == "P":

   441

                pou = project.getpou(words[1])

   442

                if pou is not None:

   443

                    pou_type = pou.getpouType()

   444

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

   445

                        pou.interface is not None):

   446

                        # Extract variables from every varLists

   447

                        for varlist_type, varlist in pou.getvars():

   448

                            var_infos = VAR_CLASS_INFOS.get(varlist_type, None)

   449

                            if var_infos is not None:

   450

                                var_class = var_infos[1]

   451

                            else:

   452

                                var_class = ITEM_VAR_LOCAL

   453

                            for variable in varlist.getvariable():

   454

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

   455

                                if var_infos is not None:

   456

                                    vars.append(var_infos)

   457

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

   458

                            for transition in pou.gettransitionList():

   459

                                vars.append({

   460

                                    "name": transition.getname(),

   461

                                    "type": None, 

   462

                                    "class": ITEM_TRANSITION,

   463

                                    "edit": True,

   464

                                    "debug": True})

   465

                            for action in pou.getactionList():

   466

                                vars.append({

   467

                                    "name": action.getname(),

   468

                                    "type": None, 

   469

                                    "class": ITEM_ACTION,

   470

                                    "edit": True,

   471

                                    "debug": True})

   472

                        return {"class": POU_TYPES[pou_type],

   473

                                "type": words[1],

   474

                                "variables": vars,

   475

                                "edit": True,

   476

                                "debug": True}

   477

                else:

   478

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

   479

                    if (block_infos is not None and 

   480

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

   481

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

   482

                            vars.append({"name" : varname, 

   483

                                         "type" : vartype, 

   484

                                         "class" : ITEM_VAR_INPUT,

   485

                                         "edit": False,

   486

                                         "debug": True})

   487

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

   488

                            vars.append({"name" : varname, 

   489

                                         "type" : vartype, 

   490

                                         "class" : ITEM_VAR_OUTPUT,

   491

                                         "edit": False,

   492

                                         "debug": True})

   493

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

   494

                                "type": None,

   495

                                "variables": vars,

   496

                                "edit": False,

   497

                                "debug": False}

   498

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

   499

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

   500

                if pou_vars is not None:

   501

                    if words[0] == 'A':

   502

                        element_type = ITEM_ACTION

   503

                    elif words[0] == 'T':

   504

                        element_type = ITEM_TRANSITION

   505

                    return {"class": element_type,

   506

                            "type": None,

   507

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

   508

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

   509

                            "edit": True,

   510

                            "debug": True}

   511

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

   512

                if words[0] == 'C':

   513

                    element_type = ITEM_CONFIGURATION

   514

                    element = project.getconfiguration(words[1])

   515

                    if element is not None:

   516

                        for resource in element.getresource():

   517

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

   518

                                         "type": None,

   519

                                         "class": ITEM_RESOURCE,

   520

                                         "edit": True,

   521

                                         "debug": False})

   522

                elif words[0] == 'R':

   523

                    element_type = ITEM_RESOURCE

   524

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

   525

                    if element is not None:

   526

                        for task in element.gettask():

   527

                            for pou in task.getpouInstance():