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, 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

   160

variables_infos_xslt = etree.parse(

   161

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

   162

   163

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

   164

#            Helpers object for generating pou variable instance list

   165

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

   166

   167

def class_extraction(el, prt):

   168

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

   169

        pou_type = POU_TYPES.get(el.text)

   170

        if pou_type is not None:

   171

            return pou_type

   172

        return VAR_CLASS_INFOS[el.text][1]

   173

    return {

   174

        "configuration": ITEM_CONFIGURATION,

   175

        "resource": ITEM_RESOURCE,

   176

        "action": ITEM_ACTION,

   177

        "transition": ITEM_TRANSITION,

   178

        "program": ITEM_PROGRAM}.get(prt)

   179

   180

PARAM_VALUE_EXTRACTION = {

   181

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

   182

    "class": class_extraction,

   183

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

   184

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

   185

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

   186

    "variables": lambda el, prt: [

   187

        compute_instance_tree(chld)

   188

        for chld in el]}

   189

   190

def compute_instance_tree(tree):

   191

    return {el.tag:

   192

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

   193

        for el in tree}

   194

   195

class IsEdited(etree.XSLTExtension):

   196

   197

    def __init__(self, controller, debug):

   198

        etree.XSLTExtension.__init__(self)

   199

        self.Controller = controller

   200

        self.Debug = debug

   201

   202

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

   203

        typename = input_node.get("name")

   204

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

   205

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

   206

   207

class IsDebugged(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

        pou_infos = project.getpou(typename)

   218

        if pou_infos is not None:

   219

            self.apply_templates(context, pou_infos, output_parent)

   220

            return

   221

   222

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

   223

        if datatype_infos is not None:

   224

            self.apply_templates(context, datatype_infos, output_parent)

   225

            return

   226

   227

        output_parent.text = "False"

   228

   229

class PouVariableClass(etree.XSLTExtension):

   230

   231

    def __init__(self, controller, debug):

   232

        etree.XSLTExtension.__init__(self)

   233

        self.Controller = controller

   234

        self.Debug = debug

   235

   236

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

   237

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

   238

        if pou_infos is not None:

   239

            self.apply_templates(context, pou_infos, output_parent)

   240

            return

   241

   242

        self.process_children(context, output_parent)

   243

   244

pou_variables_xslt = etree.parse(

   245

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

   246

   247

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

   248

#            Helpers object for generating instances path list

   249

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

   250

   251

class InstanceDefinition(etree.XSLTExtension):

   252

   253

    def __init__(self, controller, debug):

   254

        etree.XSLTExtension.__init__(self)

   255

        self.Controller = controller

   256

        self.Debug = debug

   257

   258

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

   259

        instance_infos = etree.Element('infos')

   260

        self.process_children(context, instance_infos)

   261

   262

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

   263

        if pou_infos is not None:

   264

            pou_instance = etree.Element('pou_instance',

   265

                pou_path=instance_infos.get("path"))

   266

            pou_instance.append(deepcopy(pou_infos))

   267

            self.apply_templates(context, pou_instance, output_parent)

   268

            return

   269

   270

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

   271

        if datatype_infos is not None:

   272

            datatype_instance = etree.Element('datatype_instance',

   273

                datatype_path=instance_infos.get("path"))

   274

            datatype_instance.append(deepcopy(datatype_infos))

   275

            self.apply_templates(context, datatype_instance, output_parent)

   276

            return

   277

   278

instances_path_xslt = etree.parse(

   279

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

   280

   281

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

   282

#            Helpers object for generating instance tagname

   283

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

   284

   285

class InstanceTagName(etree.XSLTExtension):

   286

   287

    def __init__(self, controller):

   288

        etree.XSLTExtension.__init__(self)

   289

        self.Controller = controller

   290

   291

    def GetTagName(self, infos):

   292

        return ""

   293

   294

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

   295

        tagname_infos = etree.Element('infos')

   296

        self.process_children(context, tagname_infos)

   297

        tagname = etree.Element('tagname')

   298

        tagname.text = self.GetTagName(tagname_infos)

   299

        output_parent.append(tagname)

   300

   301

class ConfigTagName(InstanceTagName):

   302

   303

    def GetTagName(self, infos):

   304

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

   305

   306

class ResourceTagName(InstanceTagName):

   307

   308

    def GetTagName(self, infos):

   309

        return self.Controller.ComputeConfigurationResourceName(

   310

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

   311

   312

class PouTagName(InstanceTagName):

   313

   314

    def GetTagName(self, infos):

   315

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

   316

   317

class ActionTagName(InstanceTagName):

   318

   319

    def GetTagName(self, infos):

   320

        return self.Controller.ComputePouActionName(

   321

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

   322

   323

class TransitionTagName(InstanceTagName):

   324

   325

    def GetTagName(self, infos):

   326

        return self.Controller.ComputePouTransitionName(

   327

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

   328

   329

instance_tagname_xslt = etree.parse(

   330

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

   331

   332

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

   333

#                         Undo Buffer for PLCOpenEditor

   334

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

   335

   336

# Length of the buffer

   337

UNDO_BUFFER_LENGTH = 20

   338

   339

"""

   340

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

   341

"""

   342

class UndoBuffer:

   343

   344

    # Constructor initialising buffer

   345

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

   346

        self.Buffer = []

   347

        self.CurrentIndex = -1

   348

        self.MinIndex = -1

   349

        self.MaxIndex = -1

   350

        # if current state is defined

   351

        if currentstate:

   352

            self.CurrentIndex = 0

   353

            self.MinIndex = 0

   354

            self.MaxIndex = 0

   355

        # Initialising buffer with currentstate at the first place

   356

        for i in xrange(UNDO_BUFFER_LENGTH):

   357

            if i == 0:

   358

                self.Buffer.append(currentstate)

   359

            else:

   360

                self.Buffer.append(None)

   361

        # Initialising index of state saved

   362

        if issaved:

   363

            self.LastSave = 0

   364

        else:

   365

            self.LastSave = -1

   366

   367

    # Add a new state in buffer

   368

    def Buffering(self, currentstate):

   369

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

   370

        self.Buffer[self.CurrentIndex] = currentstate

   371

        # Actualising buffer limits

   372

        self.MaxIndex = self.CurrentIndex

   373

        if self.MinIndex == self.CurrentIndex:

   374

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

   375

            if self.LastSave == self.MinIndex:

   376

                self.LastSave = -1

   377

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

   378

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

   379

   380

    # Return current state of buffer

   381

    def Current(self):

   382

        return self.Buffer[self.CurrentIndex]

   383

   384

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

   385

    def Previous(self):

   386

        if self.CurrentIndex != self.MinIndex:

   387

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

   388

            return self.Buffer[self.CurrentIndex]

   389

        return None

   390

   391

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

   392

    def Next(self):

   393

        if self.CurrentIndex != self.MaxIndex:

   394

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

   395

            return self.Buffer[self.CurrentIndex]

   396

        return None

   397

   398

    # Return True if current state is the first in buffer

   399

    def IsFirst(self):

   400

        return self.CurrentIndex == self.MinIndex

   401

   402

    # Return True if current state is the last in buffer

   403

    def IsLast(self):

   404

        return self.CurrentIndex == self.MaxIndex

   405

   406

    # Note that current state is saved

   407

    def CurrentSaved(self):

   408

        self.LastSave = self.CurrentIndex

   409

   410

    # Return True if current state is saved

   411

    def IsCurrentSaved(self):

   412

        return self.LastSave == self.CurrentIndex

   413

   414

   415

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

   416

#                           Controler for PLCOpenEditor

   417

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

   418

   419

"""

   420

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

   421

"""

   422

class PLCControler:

   423

   424

    # Create a new PLCControler

   425

    def __init__(self):

   426

        self.LastNewIndex = 0

   427

        self.Reset()

   428

   429

    # Reset PLCControler internal variables

   430

    def Reset(self):

   431

        self.Project = None

   432

        self.ProjectBufferEnabled = True

   433

        self.ProjectBuffer = None

   434

        self.ProjectSaved = True

   435

        self.Buffering = False

   436

        self.FilePath = ""

   437

        self.FileName = ""

   438

        self.ProgramChunks = []

   439

        self.ProgramOffset = 0

   440

        self.NextCompiledProject = None

   441

        self.CurrentCompiledProject = None

   442

        self.ConfNodeTypes = []

   443

        self.TotalTypesDict = StdBlckDct.copy()

   444

        self.TotalTypes = StdBlckLst[:]

   445

        self.ProgramFilePath = ""

   446

   447

    def GetQualifierTypes(self):

   448

        return QualifierList

   449

   450

    def GetProject(self, debug = False):

   451

        if debug and self.CurrentCompiledProject is not None:

   452

            return self.CurrentCompiledProject

   453

        else:

   454

            return self.Project

   455

   456

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

   457

#                         Project management functions

   458

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

   459

   460

    # Return if a project is opened

   461

    def HasOpenedProject(self):

   462

        return self.Project is not None

   463

   464

    # Create a new project by replacing the current one

   465

    def CreateNewProject(self, properties):

   466

        # Create the project

   467

        self.Project = PLCOpenParser.CreateRoot()

   468

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

   469

        self.Project.setfileHeader(properties)

   470

        self.Project.setcontentHeader(properties)

   471

        self.SetFilePath("")

   472

   473

        # Initialize the project buffer

   474

        self.CreateProjectBuffer(False)

   475

        self.ProgramChunks = []

   476

        self.ProgramOffset = 0

   477

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

   478

        self.CurrentCompiledProject = None

   479

        self.Buffering = False

   480

   481

    # Return project data type names

   482

    def GetProjectDataTypeNames(self, debug = False):

   483

        project = self.GetProject(debug)

   484

        if project is not None:

   485

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

   486

        return []

   487

   488

    # Return project pou names

   489

    def GetProjectPouNames(self, debug = False):

   490

        project = self.GetProject(debug)

   491

        if project is not None:

   492

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

   493

        return []

   494

   495

    # Return project pou names

   496

    def GetProjectConfigNames(self, debug = False):

   497

        project = self.GetProject(debug)

   498

        if project is not None:

   499

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

   500

        return []

   501

   502

    # Return project pou variable names

   503

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

   504

        variables = []

   505

        project = self.GetProject(debug)

   506

        if project is not None:

   507

            for pou in project.getpous():

   508

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

   509

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

   510

                    for transition in pou.gettransitionList():