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

#                         Undo Buffer for PLCOpenEditor

   283

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

   284

   285

# Length of the buffer

   286

UNDO_BUFFER_LENGTH = 20

   287

   288

"""

   289

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

   290

"""

   291

class UndoBuffer:

   292

   293

    # Constructor initialising buffer

   294

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

   295

        self.Buffer = []

   296

        self.CurrentIndex = -1

   297

        self.MinIndex = -1

   298

        self.MaxIndex = -1

   299

        # if current state is defined

   300

        if currentstate:

   301

            self.CurrentIndex = 0

   302

            self.MinIndex = 0

   303

            self.MaxIndex = 0

   304

        # Initialising buffer with currentstate at the first place

   305

        for i in xrange(UNDO_BUFFER_LENGTH):

   306

            if i == 0:

   307

                self.Buffer.append(currentstate)

   308

            else:

   309

                self.Buffer.append(None)

   310

        # Initialising index of state saved

   311

        if issaved:

   312

            self.LastSave = 0

   313

        else:

   314

            self.LastSave = -1

   315

   316

    # Add a new state in buffer

   317

    def Buffering(self, currentstate):

   318

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

   319

        self.Buffer[self.CurrentIndex] = currentstate

   320

        # Actualising buffer limits

   321

        self.MaxIndex = self.CurrentIndex

   322

        if self.MinIndex == self.CurrentIndex:

   323

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

   324

            if self.LastSave == self.MinIndex:

   325

                self.LastSave = -1

   326

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

   327

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

   328

   329

    # Return current state of buffer

   330

    def Current(self):

   331

        return self.Buffer[self.CurrentIndex]

   332

   333

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

   334

    def Previous(self):

   335

        if self.CurrentIndex != self.MinIndex:

   336

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

   337

            return self.Buffer[self.CurrentIndex]

   338

        return None

   339

   340

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

   341

    def Next(self):

   342

        if self.CurrentIndex != self.MaxIndex:

   343

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

   344

            return self.Buffer[self.CurrentIndex]

   345

        return None

   346

   347

    # Return True if current state is the first in buffer

   348

    def IsFirst(self):

   349

        return self.CurrentIndex == self.MinIndex

   350

   351

    # Return True if current state is the last in buffer

   352

    def IsLast(self):

   353

        return self.CurrentIndex == self.MaxIndex

   354

   355

    # Note that current state is saved

   356

    def CurrentSaved(self):

   357

        self.LastSave = self.CurrentIndex

   358

   359

    # Return True if current state is saved

   360

    def IsCurrentSaved(self):

   361

        return self.LastSave == self.CurrentIndex

   362

   363

   364

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

   365

#                           Controler for PLCOpenEditor

   366

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

   367

   368

"""

   369

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

   370

"""

   371

class PLCControler:

   372

   373

    # Create a new PLCControler

   374

    def __init__(self):

   375

        self.LastNewIndex = 0

   376

        self.Reset()

   377

   378

    # Reset PLCControler internal variables

   379

    def Reset(self):

   380

        self.Project = None

   381

        self.ProjectBufferEnabled = True

   382

        self.ProjectBuffer = None

   383

        self.ProjectSaved = True

   384

        self.Buffering = False

   385

        self.FilePath = ""

   386

        self.FileName = ""

   387

        self.ProgramChunks = []

   388

        self.ProgramOffset = 0

   389

        self.NextCompiledProject = None

   390

        self.CurrentCompiledProject = None

   391

        self.ConfNodeTypes = []

   392

        self.TotalTypesDict = StdBlckDct.copy()

   393

        self.TotalTypes = StdBlckLst[:]

   394

        self.ProgramFilePath = ""

   395

   396

    def GetQualifierTypes(self):

   397

        return QualifierList

   398

   399

    def GetProject(self, debug = False):

   400

        if debug and self.CurrentCompiledProject is not None:

   401

            return self.CurrentCompiledProject

   402

        else:

   403

            return self.Project

   404

   405

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

   406

#                         Project management functions

   407

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

   408

   409

    # Return if a project is opened

   410

    def HasOpenedProject(self):

   411

        return self.Project is not None

   412

   413

    # Create a new project by replacing the current one

   414

    def CreateNewProject(self, properties):

   415

        # Create the project

   416

        self.Project = PLCOpenParser.CreateRoot()

   417

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

   418

        self.Project.setfileHeader(properties)

   419

        self.Project.setcontentHeader(properties)

   420

        self.SetFilePath("")

   421

   422

        # Initialize the project buffer

   423

        self.CreateProjectBuffer(False)

   424

        self.ProgramChunks = []

   425

        self.ProgramOffset = 0

   426

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

   427

        self.CurrentCompiledProject = None

   428

        self.Buffering = False

   429

   430

    # Return project data type names

   431

    def GetProjectDataTypeNames(self, debug = False):

   432

        project = self.GetProject(debug)

   433

        if project is not None:

   434

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

   435

        return []

   436

   437

    # Return project pou names

   438

    def GetProjectPouNames(self, debug = False):

   439

        project = self.GetProject(debug)

   440

        if project is not None:

   441

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

   442

        return []

   443

   444

    # Return project pou names

   445

    def GetProjectConfigNames(self, debug = False):

   446

        project = self.GetProject(debug)

   447

        if project is not None:

   448

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

   449

        return []

   450

   451

    # Return project pou variable names

   452

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

   453

        variables = []

   454

        project = self.GetProject(debug)

   455

        if project is not None:

   456

            for pou in project.getpous():

   457

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

   458

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

   459

                    for transition in pou.gettransitionList():

   460

                        variables.append(transition.getname())

   461

                    for action in pou.getactionList():

   462

                        variables.append(action.getname())

   463

        return variables

   464

   465

    # Return file path if project is an open file

   466

    def GetFilePath(self):

   467

        return self.FilePath

   468

   469

    # Return file path if project is an open file

   470

    def GetProgramFilePath(self):

   471

        return self.ProgramFilePath

   472

   473

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

   474

    def GetFilename(self):

   475

        if self.Project is not None:

   476

            if self.ProjectIsSaved():

   477

                return self.FileName

   478

            else:

   479

                return "~%s~"%self.FileName

   480

        return ""

   481

   482

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

   483

    def SetFilePath(self, filepath):

   484

        self.FilePath = filepath

   485

        if filepath == "":

   486

            self.LastNewIndex += 1

   487

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

   488

        else:

   489

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

   490

   491

    # Change project properties

   492

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

   493

        if self.Project is not None:

   494

            if name is not None:

   495

                self.Project.setname(name)

   496

            if properties is not None:

   497

                self.Project.setfileHeader(properties)

   498

                self.Project.setcontentHeader(properties)

   499

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

   500

                self.BufferProject()

   501

   502

    # Return project name

   503

    def GetProjectName(self, debug=False):

   504

        project = self.GetProject(debug)

   505

        if project is not None:

   506

            return project.getname()

   507

        return None

   508

   509

    # Return project properties

   510

    def GetProjectProperties(self, debug = False):

   511

        project = self.GetProject(debug)

   512

        if project is not None:

   513

            properties = project.getfileHeader()

   514