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 el.text == "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

class VarIsEdited(etree.XSLTExtension):

   161

   162

    def __init__(self, controller, debug):

   163

        etree.XSLTExtension.__init__(self)

   164

        self.Controller = controller

   165

        self.Debug = debug

   166

   167

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

   168

        typename = input_node.get("name")

   169

        output_parent.text = str(

   170

            self.Controller.GetPou(typename, self.Debug) is None)

   171

   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

        print etree.tostring(tagname)

   312

        try:

   313

            output_parent.append(tagname)

   314

        except:

   315

            pass

   316

   317

class ConfigTagName(InstanceTagName):

   318

   319

    def GetTagName(self, infos):

   320

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

   321

   322

class ResourceTagName(InstanceTagName):

   323

   324

    def GetTagName(self, infos):

   325

        return self.Controller.ComputeConfigurationResourceName(

   326

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

   327

   328

class PouTagName(InstanceTagName):

   329

   330

    def GetTagName(self, infos):

   331

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

   332

   333

class ActionTagName(InstanceTagName):

   334

   335

    def GetTagName(self, infos):

   336

        return self.Controller.ComputePouActionName(

   337

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

   338

   339

class TransitionTagName(InstanceTagName):

   340

   341

    def GetTagName(self, infos):

   342

        return self.Controller.ComputePouTransitionName(

   343

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

   344

   345

instance_tagname_xslt = etree.parse(

   346

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

   347

   348

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

   349

#                         Undo Buffer for PLCOpenEditor

   350

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

   351

   352

# Length of the buffer

   353

UNDO_BUFFER_LENGTH = 20

   354

   355

"""

   356

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

   357

"""

   358

class UndoBuffer:

   359

   360

    # Constructor initialising buffer

   361

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

   362

        self.Buffer = []

   363

        self.CurrentIndex = -1

   364

        self.MinIndex = -1

   365

        self.MaxIndex = -1

   366

        # if current state is defined

   367

        if currentstate:

   368

            self.CurrentIndex = 0

   369

            self.MinIndex = 0

   370

            self.MaxIndex = 0

   371

        # Initialising buffer with currentstate at the first place

   372

        for i in xrange(UNDO_BUFFER_LENGTH):

   373

            if i == 0:

   374

                self.Buffer.append(currentstate)

   375

            else:

   376

                self.Buffer.append(None)

   377

        # Initialising index of state saved

   378

        if issaved:

   379

            self.LastSave = 0

   380

        else:

   381

            self.LastSave = -1

   382

   383

    # Add a new state in buffer

   384

    def Buffering(self, currentstate):

   385

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

   386

        self.Buffer[self.CurrentIndex] = currentstate

   387

        # Actualising buffer limits

   388

        self.MaxIndex = self.CurrentIndex

   389

        if self.MinIndex == self.CurrentIndex:

   390

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

   391

            if self.LastSave == self.MinIndex:

   392

                self.LastSave = -1

   393

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

   394

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

   395

   396

    # Return current state of buffer

   397

    def Current(self):

   398

        return self.Buffer[self.CurrentIndex]

   399

   400

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

   401

    def Previous(self):

   402

        if self.CurrentIndex != self.MinIndex:

   403

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

   404

            return self.Buffer[self.CurrentIndex]

   405

        return None

   406

   407

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

   408

    def Next(self):

   409

        if self.CurrentIndex != self.MaxIndex:

   410

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

   411

            return self.Buffer[self.CurrentIndex]

   412

        return None

   413

   414

    # Return True if current state is the first in buffer

   415

    def IsFirst(self):

   416

        return self.CurrentIndex == self.MinIndex

   417

   418

    # Return True if current state is the last in buffer

   419

    def IsLast(self):

   420

        return self.CurrentIndex == self.MaxIndex

   421

   422

    # Note that current state is saved

   423

    def CurrentSaved(self):

   424

        self.LastSave = self.CurrentIndex

   425

   426

    # Return True if current state is saved

   427

    def IsCurrentSaved(self):

   428

        return self.LastSave == self.CurrentIndex

   429

   430

   431

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

   432

#                           Controler for PLCOpenEditor

   433

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

   434

   435

"""

   436

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

   437

"""

   438

class PLCControler:

   439

   440

    # Create a new PLCControler

   441

    def __init__(self):

   442

        self.LastNewIndex = 0

   443

        self.Reset()

   444

   445

    # Reset PLCControler internal variables

   446

    def Reset(self):

   447

        self.Project = None

   448

        self.ProjectBufferEnabled = True

   449

        self.ProjectBuffer = None

   450

        self.ProjectSaved = True

   451

        self.Buffering = False

   452

        self.FilePath = ""

   453

        self.FileName = ""

   454

        self.ProgramChunks = []

   455

        self.ProgramOffset = 0

   456

        self.NextCompiledProject = None

   457

        self.CurrentCompiledProject = None

   458

        self.ConfNodeTypes = []

   459

        self.TotalTypesDict = StdBlckDct.copy()

   460

        self.TotalTypes = StdBlckLst[:]

   461

        self.ProgramFilePath = ""

   462

   463

    def GetQualifierTypes(self):

   464

        return QualifierList

   465

   466

    def GetProject(self, debug = False):

   467

        if debug and self.CurrentCompiledProject is not None:

   468

            return self.CurrentCompiledProject

   469

        else:

   470

            return self.Project

   471

   472

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

   473

#                         Project management functions

   474

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

   475

   476

    # Return if a project is opened

   477

    def HasOpenedProject(self):

   478

        return self.Project is not None

   479

   480

    # Create a new project by replacing the current one

   481

    def CreateNewProject(self, properties):

   482

        # Create the project

   483

        self.Project = PLCOpenParser.CreateRoot()

   484

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

   485

        self.Project.setfileHeader(properties)

   486

        self.Project.setcontentHeader(properties)

   487

        self.SetFilePath("")

   488

   489

        # Initialize the project buffer

   490

        self.CreateProjectBuffer(False)

   491

        self.ProgramChunks = []

   492

        self.ProgramOffset = 0

   493

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

   494

        self.CurrentCompiledProject = None

   495

        self.Buffering = False

   496

   497

    # Return project data type names

   498

    def GetProjectDataTypeNames(self, debug = False):

   499

        project = self.GetProject(debug)

   500

        if project is not None:

   501

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

   502

        return []

   503

   504

    # Return project pou names

   505

    def GetProjectPouNames(self, debug = False):

   506

        project = self.GetProject(debug)

   507

        if project is not None:

   508

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

   509

        return []