1

#!/usr/bin/env python

     2

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

     3

     4

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

     5

#based on the plcopen standard. 

     6

#

     7

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

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

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

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

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

    15

#

    16

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

    17

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

    18

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

    19

#General Public License for more details.

    20

#

    21

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

    22

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

    23

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

    24

    25

from xml.dom import minidom

    26

from types import StringType, UnicodeType, TupleType

    27

from lxml import etree

    28

from copy import deepcopy

    29

import os,sys,re

    30

import datetime

    31

from time import localtime

    32

    33

from plcopen 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 = {

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    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

#                 Helpers object for generating pou var list

   104

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

   105

   106

def compute_dimensions(el):

   107

    return [

   108

        (dimension.get("lower"), dimension.get("upper"))

   109

        for dimension in el.findall("dimension")]

   110

   111

def extract_param(el):

   112

    if el.tag == "Type" and el.text is None:

   113

        array = el.find("array")

   114

        return ('array', array.text, compute_dimensions(array))

   115

    elif el.tag == "Tree":

   116

        return generate_var_tree(el)

   117

    elif el.tag == "Edit":

   118

        return True

   119

    elif el.text is None:

   120

        return ''

   121

    return el.text

   122

   123

def generate_var_tree(tree):

   124

    return ([

   125

        (var.get("name"), var.text, generate_var_tree(var))

   126

         for var in tree.findall("var")],

   127

        compute_dimensions(tree))

   128

   129

class AddVariable(etree.XSLTExtension):

   130

   131

    def __init__(self, variables):

   132

        etree.XSLTExtension.__init__(self)

   133

        self.Variables = variables

   134

   135

    def execute(self, context, self_node, input_node, output_parent):

   136

        infos = etree.Element('var_infos')

   137

        self.process_children(context, infos)

   138

        self.Variables.append(

   139

            {el.tag.replace("_", " "): extract_param(el) for el in infos})

   140

   141

class VarTree(etree.XSLTExtension):

   142

   143

    def __init__(self, controller):

   144

        etree.XSLTExtension.__init__(self)

   145

        self.Controller = controller

   146

   147

    def execute(self, context, self_node, input_node, output_parent):

   148

        typename = input_node.get("name")

   149

        pou_infos = self.Controller.GetPou(typename)

   150

        if pou_infos is not None:

   151

            self.apply_templates(context, pou_infos, output_parent)

   152

            return

   153

   154

        datatype_infos = self.Controller.GetDataType(typename)

   155

        if datatype_infos is not None:

   156

            self.apply_templates(context, datatype_infos, output_parent)

   157

            return

   158

   159

variables_infos_xslt = etree.parse(

   160

    os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"))

   161

   162

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

   163

#                         Undo Buffer for PLCOpenEditor

   164

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

   165

   166

# Length of the buffer

   167

UNDO_BUFFER_LENGTH = 20

   168

   169

"""

   170

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

   171

"""

   172

class UndoBuffer:

   173

   174

    # Constructor initialising buffer

   175

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

   176

        self.Buffer = []

   177

        self.CurrentIndex = -1

   178

        self.MinIndex = -1

   179

        self.MaxIndex = -1

   180

        # if current state is defined

   181

        if currentstate:

   182

            self.CurrentIndex = 0

   183

            self.MinIndex = 0

   184

            self.MaxIndex = 0

   185

        # Initialising buffer with currentstate at the first place

   186

        for i in xrange(UNDO_BUFFER_LENGTH):

   187

            if i == 0:

   188

                self.Buffer.append(currentstate)

   189

            else:

   190

                self.Buffer.append(None)

   191

        # Initialising index of state saved

   192

        if issaved:

   193

            self.LastSave = 0

   194

        else:

   195

            self.LastSave = -1

   196

   197

    # Add a new state in buffer

   198

    def Buffering(self, currentstate):

   199

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

   200

        self.Buffer[self.CurrentIndex] = currentstate

   201

        # Actualising buffer limits

   202

        self.MaxIndex = self.CurrentIndex

   203

        if self.MinIndex == self.CurrentIndex:

   204

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

   205

            if self.LastSave == self.MinIndex:

   206

                self.LastSave = -1

   207

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

   208

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

   209

   210

    # Return current state of buffer

   211

    def Current(self):

   212

        return self.Buffer[self.CurrentIndex]

   213

   214

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

   215

    def Previous(self):

   216

        if self.CurrentIndex != self.MinIndex:

   217

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

   218

            return self.Buffer[self.CurrentIndex]

   219

        return None

   220

   221

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

   222

    def Next(self):

   223

        if self.CurrentIndex != self.MaxIndex:

   224

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

   225

            return self.Buffer[self.CurrentIndex]

   226

        return None

   227

   228

    # Return True if current state is the first in buffer

   229

    def IsFirst(self):

   230

        return self.CurrentIndex == self.MinIndex

   231

   232

    # Return True if current state is the last in buffer

   233

    def IsLast(self):

   234

        return self.CurrentIndex == self.MaxIndex

   235

   236

    # Note that current state is saved

   237

    def CurrentSaved(self):

   238

        self.LastSave = self.CurrentIndex

   239

   240

    # Return True if current state is saved

   241

    def IsCurrentSaved(self):

   242

        return self.LastSave == self.CurrentIndex

   243

   244

   245

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

   246

#                           Controler for PLCOpenEditor

   247

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

   248

   249

"""

   250

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

   251

"""

   252

class PLCControler:

   253

   254

    # Create a new PLCControler

   255

    def __init__(self):

   256

        self.LastNewIndex = 0

   257

        self.Reset()

   258

   259

    # Reset PLCControler internal variables

   260

    def Reset(self):

   261

        self.Project = None

   262

        self.ProjectBufferEnabled = True

   263

        self.ProjectBuffer = None

   264

        self.ProjectSaved = True

   265

        self.Buffering = False

   266

        self.FilePath = ""

   267

        self.FileName = ""

   268

        self.ProgramChunks = []

   269

        self.ProgramOffset = 0

   270

        self.NextCompiledProject = None

   271

        self.CurrentCompiledProject = None

   272

        self.ConfNodeTypes = []

   273

        self.TotalTypesDict = StdBlckDct.copy()

   274

        self.TotalTypes = StdBlckLst[:]

   275

        self.ProgramFilePath = ""

   276

   277

    def GetQualifierTypes(self):

   278

        return QualifierList

   279

   280

    def GetProject(self, debug = False):

   281

        if debug and self.CurrentCompiledProject is not None:

   282

            return self.CurrentCompiledProject

   283

        else:

   284

            return self.Project

   285

   286

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

   287

#                         Project management functions

   288

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

   289

   290

    # Return if a project is opened

   291

    def HasOpenedProject(self):

   292

        return self.Project is not None

   293

   294

    # Create a new project by replacing the current one

   295

    def CreateNewProject(self, properties):

   296

        # Create the project

   297

        self.Project = PLCOpenParser.CreateRoot()

   298

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

   299

        self.Project.setfileHeader(properties)

   300

        self.Project.setcontentHeader(properties)

   301

        self.SetFilePath("")

   302

   303

        # Initialize the project buffer

   304

        self.CreateProjectBuffer(False)

   305

        self.ProgramChunks = []

   306

        self.ProgramOffset = 0

   307

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

   308

        self.CurrentCompiledProject = None

   309

        self.Buffering = False

   310

   311

    # Return project data type names

   312

    def GetProjectDataTypeNames(self, debug = False):

   313

        project = self.GetProject(debug)

   314

        if project is not None:

   315

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

   316

        return []

   317

   318

    # Return project pou names

   319

    def GetProjectPouNames(self, debug = False):

   320

        project = self.GetProject(debug)

   321

        if project is not None:

   322

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

   323

        return []

   324

   325

    # Return project pou names

   326

    def GetProjectConfigNames(self, debug = False):

   327

        project = self.GetProject(debug)

   328

        if project is not None:

   329

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

   330

        return []

   331

   332

    # Return project pou variable names

   333

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

   334

        variables = []

   335

        project = self.GetProject(debug)

   336

        if project is not None:

   337

            for pou in project.getpous():

   338

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

   339

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

   340

                    for transition in pou.gettransitionList():

   341

                        variables.append(transition.getname())

   342

                    for action in pou.getactionList():

   343

                        variables.append(action.getname())

   344

        return variables

   345

   346

    # Return file path if project is an open file

   347

    def GetFilePath(self):

   348

        return self.FilePath

   349

   350

    # Return file path if project is an open file

   351

    def GetProgramFilePath(self):

   352

        return self.ProgramFilePath

   353

   354

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

   355

    def GetFilename(self):

   356

        if self.Project is not None:

   357

            if self.ProjectIsSaved():

   358

                return self.FileName

   359

            else:

   360

                return "~%s~"%self.FileName

   361

        return ""

   362

   363

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

   364

    def SetFilePath(self, filepath):

   365

        self.FilePath = filepath

   366

        if filepath == "":

   367

            self.LastNewIndex += 1

   368

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

   369

        else:

   370

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

   371

   372

    # Change project properties

   373

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

   374

        if self.Project is not None:

   375

            if name is not None:

   376

                self.Project.setname(name)

   377

            if properties is not None:

   378

                self.Project.setfileHeader(properties)

   379

                self.Project.setcontentHeader(properties)

   380

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

   381

                self.BufferProject()

   382

   383

    # Return project name

   384

    def GetProjectName(self, debug=False):

   385

        project = self.GetProject(debug)

   386

        if project is not None:

   387

            return project.getname()

   388

        return None

   389

   390

    # Return project properties

   391

    def GetProjectProperties(self, debug = False):

   392

        project = self.GetProject(debug)

   393

        if project is not None:

   394

            properties = project.getfileHeader()

   395

            properties.update(project.getcontentHeader())

   396

            return properties

   397

        return None

   398

   399

    # Return project informations

   400

    def GetProjectInfos(self, debug = False):

   401

        project = self.GetProject(debug)

   402

        if project is not None:

   403

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

   404

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

   405

            for datatype in project.getdataTypes():

   406

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

   407

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

   408

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

   409

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

   410

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

   411

            for pou in project.getpous():

   412

                pou_type = pou.getpouType()

   413

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

   414

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

   415

                pou_values = []

   416

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

   417

                    transitions = []

   418

                    for transition in pou.gettransitionList():

   419

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

   420

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

   421

                            "values": []})

   422

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

   423

                    actions = []

   424

                    for action in pou.getactionList():

   425

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

   426

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

   427

                            "values": []})

   428

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

   429

                if pou_type in pou_types:

   430

                    pou_infos["values"] = pou_values

   431

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

   432

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

   433

            for config in project.getconfigurations():

   434

                config_name = config.getname()

   435

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

   436

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

   437

                    "values": []}

   438

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

   439

                for resource in config.getresource():

   440

                    resource_name = resource.getname()

   441

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

   442

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

   443

                        "values": []}

   444

                    resources["values"].append(resource_infos)

   445

                config_infos["values"] = [resources]

   446

                configurations["values"].append(config_infos)

   447

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

   448

                               pou_types["program"], configurations]

   449

            return infos

   450

        return None

   451

   452

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

   453

        vartype_content = variable.gettype().getcontent()

   454

        vartype_content_type = vartype_content.getLocalTag()

   455

        if vartype_content_type == "derived":

   456

            var_type = vartype_content.getname()

   457

            pou_type = None

   458

            pou = project.getpou(var_type)

   459

            if pou is not None:

   460

                pou_type = pou.getpouType()

   461

            edit = debug = pou_type is not None

   462

            if pou_type is None:

   463

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

   464

                if block_infos is not None:

   465

                    pou_type = block_infos["type"]

   466

            if pou_type is not None:

   467

                var_class = None

   468

                if pou_type == "program":

   469

                    var_class = ITEM_PROGRAM

   470

                elif pou_type != "function":

   471

                    var_class = ITEM_FUNCTIONBLOCK

   472

                if var_class is not None:

   473

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

   474

                            "type": var_type, 

   475

                            "class": var_class,

   476

                            "edit": edit,

   477

                            "debug": debug}

   478

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

   479

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

   480

                        "type": var_type, 

   481

                        "class": var_class,

   482

                        "edit": False,

   483

                        "debug": False}

   484

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

   485

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

   486

                    "type": vartype_content_type.upper(), 

   487

                    "class": var_class,

   488

                    "edit": False,

   489

                    "debug": True}

   490

        else:

   491

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

   492

                    "type": vartype_content_type, 

   493

                    "class": var_class,

   494

                    "edit": False,

   495

                    "debug": True}

   496

        return None

   497

   498

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

   499

        vars = []

   500

        pou_type = None

   501

        project = self.GetProject(debug)

   502

        if project is not None:

   503

            words = tagname.split("::")

   504

            if words[0] == "P":

   505

                pou = project.getpou(words[1])

   506

                if pou is not None:

   507

                    pou_type = pou.getpouType()

   508

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

   509

                        pou.interface is not None):

   510

                        # Extract variables from every varLists

   511

                        for varlist_type, varlist in pou.getvars():

   512

                            var_infos = VAR_CLASS_INFOS.get(varlist_type, None)

   513

                            if var_infos is not None:

   514

                                var_class = var_infos[1]

   515

                            else:

   516

                                var_class = ITEM_VAR_LOCAL

   517

                            for variable in varlist.getvariable():

   518

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

   519

                                if var_infos is not None:

   520

                                    vars.append(var_infos)

   521

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

   522