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":

   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, debug):

   144

        etree.XSLTExtension.__init__(self)

   145

        self.Controller = controller

   146

        self.Debug = debug

   147

   148

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

   149

        typename = input_node.get("name")

   150

        pou_infos = self.Controller.GetPou(typename, self.Debug)

   151

        if pou_infos is not None:

   152

            self.apply_templates(context, pou_infos, output_parent)

   153

            return

   154

   155

        datatype_infos = self.Controller.GetDataType(typename, self.Debug)

   156

        if datatype_infos is not None:

   157

            self.apply_templates(context, datatype_infos, output_parent)

   158

            return

   159

   172

variables_infos_xslt = etree.parse(

   173

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

   174

   175

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

   176

#            Helpers object for generating pou variable instance list

   177

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

   178

   179

def class_extraction(el, prt):

   180

    if prt in ["pou", "variable"]:

   181

        pou_type = POU_TYPES.get(el.text)

   182

        if pou_type is not None:

   183

            return pou_type

   184

        return VAR_CLASS_INFOS[el.text][1]

   185

    return {

   186

        "configuration": ITEM_CONFIGURATION,

   187

        "resource": ITEM_RESOURCE,

   188

        "action": ITEM_ACTION,

   189

        "transition": ITEM_TRANSITION,

   190

        "program": ITEM_PROGRAM}.get(prt)

   191

   192

PARAM_VALUE_EXTRACTION = {

   193

    "name": lambda el, prt: el.text,

   194

    "class": class_extraction,

   195

    "type": lambda el, prt: None if el.text == "None" else el.text,

   196

    "edit": lambda el, prt: el.text == "True",

   197

    "debug": lambda el, prt: el.text == "True",

   198

    "variables": lambda el, prt: [

   199

        compute_instance_tree(chld)

   200

        for chld in el]}

   201

   202

def compute_instance_tree(tree):

   203

    return {el.tag:

   204

        PARAM_VALUE_EXTRACTION[el.tag](el, tree.tag)

   205

        for el in tree}

   206

   207

class IsEdited(etree.XSLTExtension):

   208

   209

    def __init__(self, controller, debug):

   210

        etree.XSLTExtension.__init__(self)

   211

        self.Controller = controller

   212

        self.Debug = debug

   213

   214

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

   215

        typename = input_node.get("name")

   216

        project = self.Controller.GetProject(self.Debug)

   217

        output_parent.text = str(project.getpou(typename) is not None)

   218

   219

class IsDebugged(etree.XSLTExtension):

   220

   221

    def __init__(self, controller, debug):

   222

        etree.XSLTExtension.__init__(self)

   223

        self.Controller = controller

   224

        self.Debug = debug

   225

   226

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

   227

        typename = input_node.get("name")

   228

        project = self.Controller.GetProject(self.Debug)

   229

        pou_infos = project.getpou(typename)

   230

        if pou_infos is not None:

   231

            self.apply_templates(context, pou_infos, output_parent)

   232

            return

   233

   234

        datatype_infos = self.Controller.GetDataType(typename, self.Debug)

   235

        if datatype_infos is not None:

   236

            self.apply_templates(context, datatype_infos, output_parent)

   237

            return

   238

   239

        output_parent.text = "False"

   240

   241

class PouVariableClass(etree.XSLTExtension):

   242

   243

    def __init__(self, controller, debug):

   244

        etree.XSLTExtension.__init__(self)

   245

        self.Controller = controller

   246

        self.Debug = debug

   247

   248

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

   249

        pou_infos = self.Controller.GetPou(input_node.get("name"), self.Debug)

   250

        if pou_infos is not None:

   251

            self.apply_templates(context, pou_infos, output_parent)

   252

            return

   253

   254

        self.process_children(context, output_parent)

   255

   256

pou_variables_xslt = etree.parse(

   257

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

   258

   259

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

   260

#            Helpers object for generating instances path list

   261

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

   262

   263

class InstanceDefinition(etree.XSLTExtension):

   264

   265

    def __init__(self, controller, debug):

   266

        etree.XSLTExtension.__init__(self)

   267

        self.Controller = controller

   268

        self.Debug = debug

   269

   270

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

   271

        instance_infos = etree.Element('infos')

   272

        self.process_children(context, instance_infos)

   273

   274

        pou_infos = self.Controller.GetPou(instance_infos.get("name"), self.Debug)

   275

        if pou_infos is not None:

   276

            pou_instance = etree.Element('pou_instance',

   277

                pou_path=instance_infos.get("path"))

   278

            pou_instance.append(deepcopy(pou_infos))

   279

            self.apply_templates(context, pou_instance, output_parent)

   280

            return

   281

   282

        datatype_infos = self.Controller.GetDataType(instance_infos.get("name"), self.Debug)

   283

        if datatype_infos is not None:

   284

            datatype_instance = etree.Element('datatype_instance',

   285

                datatype_path=instance_infos.get("path"))

   286

            datatype_instance.append(deepcopy(datatype_infos))

   287

            self.apply_templates(context, datatype_instance, output_parent)

   288

            return

   289

   290

instances_path_xslt = etree.parse(

   291

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

   292

   293

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

   294

#            Helpers object for generating instance tagname

   295

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

   296

   297

class InstanceTagName(etree.XSLTExtension):

   298

   299

    def __init__(self, controller):

   300

        etree.XSLTExtension.__init__(self)

   301

        self.Controller = controller

   302

   303

    def GetTagName(self, infos):

   304

        return ""

   305

   306

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

   307

        tagname_infos = etree.Element('infos')

   308

        self.process_children(context, tagname_infos)

   309

        tagname = etree.Element('tagname')

   310

        tagname.text = self.GetTagName(tagname_infos)

   311

        output_parent.append(tagname)

   312

   313

class ConfigTagName(InstanceTagName):

   314

   315

    def GetTagName(self, infos):

   316

        return self.Controller.ComputeConfigurationName(infos.get("name"))

   317

   318

class ResourceTagName(InstanceTagName):

   319

   320

    def GetTagName(self, infos):

   321

        return self.Controller.ComputeConfigurationResourceName(

   322

            infos.get("config_name"), infos.get("name"))

   323

   324

class PouTagName(InstanceTagName):

   325

   326

    def GetTagName(self, infos):

   327

        return self.Controller.ComputePouName(infos.get("name"))

   328

   329

class ActionTagName(InstanceTagName):

   330

   331

    def GetTagName(self, infos):

   332

        return self.Controller.ComputePouActionName(

   333

            infos.get("pou_name"), infos.get("name"))

   334

   335

class TransitionTagName(InstanceTagName):

   336

   337

    def GetTagName(self, infos):

   338

        return self.Controller.ComputePouTransitionName(

   339

            infos.get("pou_name"), infos.get("name"))

   340

   341

instance_tagname_xslt = etree.parse(

   342

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

   343

   344

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

   345

#                         Undo Buffer for PLCOpenEditor

   346

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

   347

   348

# Length of the buffer

   349

UNDO_BUFFER_LENGTH = 20

   350

   351

"""

   352

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

   353

"""

   354

class UndoBuffer:

   355

   356

    # Constructor initialising buffer

   357

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

   358

        self.Buffer = []

   359

        self.CurrentIndex = -1

   360

        self.MinIndex = -1

   361

        self.MaxIndex = -1

   362

        # if current state is defined

   363

        if currentstate:

   364

            self.CurrentIndex = 0

   365

            self.MinIndex = 0

   366

            self.MaxIndex = 0

   367

        # Initialising buffer with currentstate at the first place

   368

        for i in xrange(UNDO_BUFFER_LENGTH):

   369

            if i == 0:

   370

                self.Buffer.append(currentstate)

   371

            else:

   372

                self.Buffer.append(None)

   373

        # Initialising index of state saved

   374

        if issaved:

   375

            self.LastSave = 0

   376

        else:

   377

            self.LastSave = -1

   378

   379

    # Add a new state in buffer

   380

    def Buffering(self, currentstate):

   381

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

   382

        self.Buffer[self.CurrentIndex] = currentstate

   383

        # Actualising buffer limits

   384

        self.MaxIndex = self.CurrentIndex

   385

        if self.MinIndex == self.CurrentIndex:

   386

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

   387

            if self.LastSave == self.MinIndex:

   388

                self.LastSave = -1

   389

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

   390

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

   391

   392

    # Return current state of buffer

   393

    def Current(self):

   394

        return self.Buffer[self.CurrentIndex]

   395

   396

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

   397

    def Previous(self):

   398

        if self.CurrentIndex != self.MinIndex:

   399

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

   400

            return self.Buffer[self.CurrentIndex]

   401

        return None

   402

   403

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

   404

    def Next(self):

   405

        if self.CurrentIndex != self.MaxIndex:

   406

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

   407

            return self.Buffer[self.CurrentIndex]

   408

        return None

   409

   410

    # Return True if current state is the first in buffer

   411

    def IsFirst(self):

   412

        return self.CurrentIndex == self.MinIndex

   413

   414

    # Return True if current state is the last in buffer

   415

    def IsLast(self):

   416

        return self.CurrentIndex == self.MaxIndex

   417

   418

    # Note that current state is saved

   419

    def CurrentSaved(self):

   420

        self.LastSave = self.CurrentIndex

   421

   422

    # Return True if current state is saved

   423

    def IsCurrentSaved(self):

   424

        return self.LastSave == self.CurrentIndex

   425

   426

   427

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

   428

#                           Controler for PLCOpenEditor

   429

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

   430

   431

"""

   432

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

   433

"""

   434

class PLCControler:

   435

   436

    # Create a new PLCControler

   437

    def __init__(self):

   438

        self.LastNewIndex = 0

   439

        self.Reset()

   440

   441

    # Reset PLCControler internal variables

   442

    def Reset(self):

   443

        self.Project = None

   444

        self.ProjectBufferEnabled = True

   445

        self.ProjectBuffer = None

   446

        self.ProjectSaved = True

   447

        self.Buffering = False

   448

        self.FilePath = ""

   449

        self.FileName = ""

   450

        self.ProgramChunks = []

   451

        self.ProgramOffset = 0

   452

        self.NextCompiledProject = None

   453

        self.CurrentCompiledProject = None

   454

        self.ConfNodeTypes = []

   455

        self.TotalTypesDict = StdBlckDct.copy()

   456

        self.TotalTypes = StdBlckLst[:]

   457

        self.ProgramFilePath = ""

   458

   459

    def GetQualifierTypes(self):

   460

        return QualifierList

   461

   462

    def GetProject(self, debug = False):

   463

        if debug and self.CurrentCompiledProject is not None:

   464

            return self.CurrentCompiledProject

   465

        else:

   466

            return self.Project

   467

   468

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

   469

#                         Project management functions

   470

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

   471

   472

    # Return if a project is opened

   473

    def HasOpenedProject(self):

   474

        return self.Project is not None

   475

   476

    # Create a new project by replacing the current one

   477

    def CreateNewProject(self, properties):

   478

        # Create the project

   479

        self.Project = PLCOpenParser.CreateRoot()

   480

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

   481

        self.Project.setfileHeader(properties)

   482

        self.Project.setcontentHeader(properties)

   483

        self.SetFilePath("")

   484

   485

        # Initialize the project buffer

   486

        self.CreateProjectBuffer(False)

   487

        self.ProgramChunks = []

   488

        self.ProgramOffset = 0

   489

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

   490

        self.CurrentCompiledProject = None

   491

        self.Buffering = False

   492

   493

    # Return project data type names

   494

    def GetProjectDataTypeNames(self, debug = False):

   495

        project = self.GetProject(debug)

   496

        if project is not None:

   497

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

   498

        return []

   499

   500

    # Return project pou names

   501

    def GetProjectPouNames(self, debug = False):

   502

        project = self.GetProject(debug)

   503

        if project is not None:

   504

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

   505

        return []

   506

   507

    # Return project pou names

   508

    def GetProjectConfigNames(self, debug = False):

   509

        project = self.GetProject(debug)