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.TotalTypesDict = StdBlckDct.copy()

   214

        self.TotalTypes = StdBlckLst[:]

   217

    def GetQualifierTypes(self):

   218

        return plcopen.QualifierList

   219

   220

    def GetProject(self, debug = False):

   221

        if debug and self.CurrentCompiledProject is not None:

   222

            return self.CurrentCompiledProject

   223

        else:

   224

            return self.Project

   225

   226

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

   227

#                         Project management functions

   228

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

   229

   230

    # Return if a project is opened

   231

    def HasOpenedProject(self):

   232

        return self.Project is not None

   233

   234

    # Create a new project by replacing the current one

   235

    def CreateNewProject(self, properties):

   236

        # Create the project

   237

        self.Project = plcopen.project()

   238

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

   239

        self.Project.setfileHeader(properties)

   240

        self.Project.setcontentHeader(properties)

   241

        self.SetFilePath("")

   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

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

   394

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

   395

            pou_type = None

   396

            pou = project.getpou(var_type)

   397

            if pou is not None:

   398

                pou_type = pou.getpouType()

   399

            edit = debug = pou_type is not None

   400

            if pou_type is None:

   401

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

   402

                if block_infos is not None:

   403

                    pou_type = block_infos["type"]

   404

            if pou_type is not None:

   405

                var_class = None

   406

                if pou_type == "program":

   407

                    var_class = ITEM_PROGRAM

   408

                elif pou_type != "function":

   409

                    var_class = ITEM_FUNCTIONBLOCK

   410

                if var_class is not None:

   411

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

   412

                            "type": var_type, 

   413

                            "class": var_class,

   414

                            "edit": edit,

   415

                            "debug": debug}

   416

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

   417

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

   418

                        "type": var_type, 

   419

                        "class": var_class,

   420

                        "edit": False,

   421

                        "debug": False}

   422

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

   423

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

   424

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

   425

                    "class": var_class,

   426

                    "edit": False,

   427

                    "debug": True}

   428

        else:

   429

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

   430

                    "type": vartype_content["name"], 

   431

                    "class": var_class,

   432

                    "edit": False,

   433

                    "debug": True}

   434

        return None

   435

   436

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

   437

        vars = []

   438

        pou_type = None

   439

        project = self.GetProject(debug)

   440

        if project is not None:

   441

            words = tagname.split("::")

   442

            if words[0] == "P":

   443

                pou = project.getpou(words[1])

   444

                if pou is not None:

   445

                    pou_type = pou.getpouType()

   446

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

   447

                        pou.interface is not None):

   448

                        # Extract variables from every varLists

   449

                        for varlist_type, varlist in pou.getvars():

   450

                            var_infos = VAR_CLASS_INFOS.get(varlist_type, None)

   451

                            if var_infos is not None:

   452

                                var_class = var_infos[1]

   453

                            else:

   454

                                var_class = ITEM_VAR_LOCAL

   455

                            for variable in varlist.getvariable():

   456

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

   457

                                if var_infos is not None:

   458

                                    vars.append(var_infos)

   459

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

   460

                            for transition in pou.gettransitionList():

   461

                                vars.append({

   462

                                    "name": transition.getname(),

   463

                                    "type": None, 

   464

                                    "class": ITEM_TRANSITION,

   465

                                    "edit": True,

   466

                                    "debug": True})

   467

                            for action in pou.getactionList():

   468

                                vars.append({

   469

                                    "name": action.getname(),

   470

                                    "type": None, 

   471

                                    "class": ITEM_ACTION,

   472

                                    "edit": True,

   473

                                    "debug": True})

   474

                        return {"class": POU_TYPES[pou_type],

   475

                                "type": words[1],

   476

                                "variables": vars,

   477

                                "edit": True,

   478

                                "debug": True}

   479

                else:

   480

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

   481

                    if (block_infos is not None and 

   482

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

   483

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

   484

                            vars.append({"name" : varname, 

   485

                                         "type" : vartype, 

   486

                                         "class" : ITEM_VAR_INPUT,

   487

                                         "edit": False,

   488

                                         "debug": True})

   489

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

   490

                            vars.append({"name" : varname, 

   491

                                         "type" : vartype, 

   492

                                         "class" : ITEM_VAR_OUTPUT,

   493

                                         "edit": False,

   494

                                         "debug": True})

   495

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

   496

                                "type": None,

   497

                                "variables": vars,

   498

                                "edit": False,

   499

                                "debug": False}

   500

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

   501

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

   502

                if pou_vars is not None:

   503

                    if words[0] == 'A':

   504

                        element_type = ITEM_ACTION

   505

                    elif words[0] == 'T':

   506

                        element_type = ITEM_TRANSITION

   507

                    return {"class": element_type,

   508

                            "type": None,

   509

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

   510

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

   511

                            "edit": True,

   512

                            "debug": True}

   513

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

   514

                if words[0] == 'C':

   515

                    element_type = ITEM_CONFIGURATION

   516

                    element = project.getconfiguration(words[1])

   517

                    if element is not None:

   518

                        for resource in element.getresource():

   519

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

   520

                                         "type": None,

   521

                                         "class": ITEM_RESOURCE,

   522

                                         "edit": True,

   523

                                         "debug": False})

   524

                elif words[0] == 'R':

   525

                    element_type = ITEM_RESOURCE

   526

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

   527