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

from collections import OrderedDict, namedtuple

    33

    34

from plcopen import *

    35

from graphics.GraphicCommons import *

    36

from PLCGenerator import *

    37

    38

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)?")

    39

    40

ITEMS_EDITABLE = [ITEM_PROJECT,

    41

                  ITEM_POU,

    42

                  ITEM_VARIABLE,

    43

                  ITEM_TRANSITION,

    44

                  ITEM_ACTION,

    45

                  ITEM_CONFIGURATION,

    46

                  ITEM_RESOURCE,

    47

                  ITEM_DATATYPE

    48

                 ] = range(8)

    49

    50

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    51

                    ITEM_FUNCTION,

    52

                    ITEM_FUNCTIONBLOCK,

    53

                    ITEM_PROGRAM,

    54

                    ITEM_TRANSITIONS,

    55

                    ITEM_ACTIONS,

    56

                    ITEM_CONFIGURATIONS,

    57

                    ITEM_RESOURCES,

    58

                    ITEM_PROPERTIES

    59

                   ] = range(8, 17)

    60

    61

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    62

                  ITEM_VAR_GLOBAL,

    63

                  ITEM_VAR_EXTERNAL,

    64

                  ITEM_VAR_TEMP,

    65

                  ITEM_VAR_INPUT,

    66

                  ITEM_VAR_OUTPUT,

    67

                  ITEM_VAR_INOUT

    68

                 ] = range(17, 24)

    69

    70

VAR_CLASS_INFOS = {

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

    79

POU_TYPES = {"program": ITEM_PROGRAM,

    80

             "functionBlock": ITEM_FUNCTIONBLOCK,

    81

             "function": ITEM_FUNCTION,

    82

            }

    83

    84

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    85

                   LOCATION_MODULE,

    86

                   LOCATION_GROUP,

    87

                   LOCATION_VAR_INPUT,

    88

                   LOCATION_VAR_OUTPUT,

    89

                   LOCATION_VAR_MEMORY] = range(6)

    90

    91

ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]

    92

    93

def GetUneditableNames():

    94

    _ = lambda x:x

    95

    return [_("User-defined POUs"), _("Functions"), _("Function Blocks"), 

    96

            _("Programs"), _("Data Types"), _("Transitions"), _("Actions"), 

    97

            _("Configurations"), _("Resources"), _("Properties")]

    98

UNEDITABLE_NAMES = GetUneditableNames()

    99

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS, 

   100

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS, 

   101

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   102

   103

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

   140

#                 Helpers object for generating pou var list

   141

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

   142

   153

   154

    def __init__(self, variables):

   155

        self.Variables = variables

   187

   188

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

   189

#            Helpers object for generating pou variable instance list

   190

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

   191

   192

def class_extraction(el, prt):

   193

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

   194

        pou_type = POU_TYPES.get(el.text)

   195

        if pou_type is not None:

   196

            return pou_type

   197

        return VAR_CLASS_INFOS[el.text][1]

   198

    return {

   199

        "configuration": ITEM_CONFIGURATION,

   200

        "resource": ITEM_RESOURCE,

   201

        "action": ITEM_ACTION,

   202

        "transition": ITEM_TRANSITION,

   203

        "program": ITEM_PROGRAM}.get(prt)

   204

   205

PARAM_VALUE_EXTRACTION = {

   206

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

   207

    "class": class_extraction,

   208

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

   209

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

   210

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

   211

    "variables": lambda el, prt: [

   212

        compute_instance_tree(chld)

   213

        for chld in el]}

   214

   215

def compute_instance_tree(tree):

   216

    return {el.tag:

   217

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

   218

        for el in tree}

   219

   220

class IsEdited(etree.XSLTExtension):

   221

   222

    def __init__(self, controller, debug):

   223

        etree.XSLTExtension.__init__(self)

   224

        self.Controller = controller

   225

        self.Debug = debug

   226

   227

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

   228

        typename = input_node.get("name")

   229

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

   230

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

   231

   232

class IsDebugged(etree.XSLTExtension):

   233

   234

    def __init__(self, controller, debug):

   235

        etree.XSLTExtension.__init__(self)

   236

        self.Controller = controller

   237

        self.Debug = debug

   238

   239

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

   240

        typename = input_node.get("name")

   241

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

   242

        pou_infos = project.getpou(typename)

   243

        if pou_infos is not None:

   244

            self.apply_templates(context, pou_infos, output_parent)

   245

            return

   246

   247

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

   248

        if datatype_infos is not None:

   249

            self.apply_templates(context, datatype_infos, output_parent)

   250

            return

   251

   252

        output_parent.text = "False"

   253

   254

class PouVariableClass(etree.XSLTExtension):

   255

   256

    def __init__(self, controller, debug):

   257

        etree.XSLTExtension.__init__(self)

   258

        self.Controller = controller

   259

        self.Debug = debug

   260

   261

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

   262

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

   263

        if pou_infos is not None:

   264

            self.apply_templates(context, pou_infos, output_parent)

   265

            return

   266

   267

        self.process_children(context, output_parent)

   268

   269

pou_variables_xslt = etree.parse(

   270

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

   271

   272

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

   273

#            Helpers object for generating instances path list

   274

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

   275

   276

class InstanceDefinition(etree.XSLTExtension):

   277

   278

    def __init__(self, controller, debug):

   279

        etree.XSLTExtension.__init__(self)

   280

        self.Controller = controller

   281

        self.Debug = debug

   282

   283

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

   284

        instance_infos = etree.Element('infos')

   285

        self.process_children(context, instance_infos)

   286

   287

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

   288

        if pou_infos is not None:

   289

            pou_instance = etree.Element('pou_instance',

   290

                pou_path=instance_infos.get("path"))

   291

            pou_instance.append(deepcopy(pou_infos))

   292

            self.apply_templates(context, pou_instance, output_parent)

   293

            return

   294

   295

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

   296

        if datatype_infos is not None:

   297

            datatype_instance = etree.Element('datatype_instance',

   298

                datatype_path=instance_infos.get("path"))

   299

            datatype_instance.append(deepcopy(datatype_infos))

   300

            self.apply_templates(context, datatype_instance, output_parent)

   301

            return

   302

   303

instances_path_xslt = etree.parse(

   304

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

   305

   306

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

   307

#            Helpers object for generating instance tagname

   308

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

   309

   310

class InstanceTagName(etree.XSLTExtension):

   311

   312

    def __init__(self, controller):

   313

        etree.XSLTExtension.__init__(self)

   314

        self.Controller = controller

   315

   316

    def GetTagName(self, infos):

   317

        return ""

   318

   319

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

   320

        tagname_infos = etree.Element('infos')

   321

        self.process_children(context, tagname_infos)

   322

        tagname = etree.Element('tagname')

   323

        tagname.text = self.GetTagName(tagname_infos)

   324

        try:

   325

            output_parent.append(tagname)

   326

        except:

   327

            pass

   328

   329

class ConfigTagName(InstanceTagName):

   330

   331

    def GetTagName(self, infos):

   332

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

   333

   334

class ResourceTagName(InstanceTagName):

   335

   336

    def GetTagName(self, infos):

   337

        return self.Controller.ComputeConfigurationResourceName(

   338

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

   339

   340

class PouTagName(InstanceTagName):

   341

   342

    def GetTagName(self, infos):

   343

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

   344

   345

class ActionTagName(InstanceTagName):

   346

   347

    def GetTagName(self, infos):

   348

        return self.Controller.ComputePouActionName(

   349

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

   350

   351

class TransitionTagName(InstanceTagName):

   352

   353

    def GetTagName(self, infos):

   354

        return self.Controller.ComputePouTransitionName(

   355

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

   356

   357

instance_tagname_xslt = etree.parse(

   358

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

   359

   360

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

   361

#           Helpers object for generating pou block instances list

   362

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

   363

   364

_Point = namedtuple("Point", ["x", "y"])

   365

   366

_BlockInstanceInfos = namedtuple("BlockInstanceInfos", 

   367

    ["type", "id", "x", "y", "width", "height", "specific_values", "inputs", "outputs"])

   368

   369

_BlockSpecificValues = (

   370

    namedtuple("BlockSpecificValues", 

   371

               ["name", "execution_order"]),

   372

    [str, int])

   373

_VariableSpecificValues = (

   374

    namedtuple("VariableSpecificValues", 

   375

               ["name", "value_type", "execution_order"]),

   376

    [str, str, int])

   377

_ConnectionSpecificValues = (

   378

    namedtuple("ConnectionSpecificValues", ["name"]),

   379

    [str])

   380

   381

_PowerRailSpecificValues = (

   382

    namedtuple("PowerRailSpecificValues", ["connectors"]),

   383

    [int])

   384

   385

_LDElementSpecificValues = (

   386

    namedtuple("LDElementSpecificValues", 

   387

               ["name", "negated", "edge", "storage", "execution_order"]),

   388

    [str, _BoolValue, str, str, int])

   389

   390

_DivergenceSpecificValues = (

   391

    namedtuple("DivergenceSpecificValues", ["connectors"]),

   392

    [int])

   393

   394

_SpecificValuesTuples = {

   395

    "comment": (

   396

        namedtuple("CommentSpecificValues", ["content"]),

   397

        [str]),

   398

    "input": _VariableSpecificValues,

   399

    "output": _VariableSpecificValues,

   400

    "inout": _VariableSpecificValues,

   401

    "connector": _ConnectionSpecificValues,

   402

    "continuation": _ConnectionSpecificValues,

   403

    "leftPowerRail": _PowerRailSpecificValues,

   404

    "rightPowerRail": _PowerRailSpecificValues,

   405

    "contact": _LDElementSpecificValues,

   406

    "coil": _LDElementSpecificValues,

   407

    "step": (

   408

        namedtuple("StepSpecificValues", ["name", "initial", "action"]),

   409

        [str, _BoolValue, lambda x: x]),

   410

    "transition": (

   411

        namedtuple("TransitionSpecificValues", 

   412

                   ["priority", "condition_type", "condition", "connection"]),

   413

        [int, str, str, lambda x: x]),

   414

    "selectionDivergence": _DivergenceSpecificValues,

   415

    "selectionConvergence": _DivergenceSpecificValues,

   416

    "simultaneousDivergence": _DivergenceSpecificValues,

   417

    "simultaneousConvergence": _DivergenceSpecificValues,

   418

    "jump": (

   419

        namedtuple("JumpSpecificValues", ["target"]),

   420

        [str]),

   421

    "actionBlock": (

   422

        namedtuple("ActionBlockSpecificValues", ["actions"]),

   423

        [lambda x: x]),

   424

}

   425

   426

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   427

    ["name", "negated", "edge", "position", "links"])

   428

   429

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   430

    ["refLocalId", "formalParameter", "points"])

   431

   432

class _ActionInfos(object):

   433

    __slots__ = ["qualifier", "type", "value", "duration", "indicator"]

   434

    def __init__(self, *args):

   435

        for attr, value in zip(self.__slots__, args):

   436

            setattr(self, attr, value if value is not None else "")

   437

    def copy(self):

   438

        return _ActionInfos(*[getattr(self, attr) for attr in self.__slots__])

   439

   440

class BlockInstanceFactory:

   441

   442

    def __init__(self, block_instances):

   443

        self.BlockInstances = block_instances

   444

        self.CurrentInstance = None

   445

        self.SpecificValues = None

   446

        self.CurrentConnection = None

   447

        self.CurrentLink = None

   448

   449

    def SetSpecificValues(self, context, *args):

   450

        self.SpecificValues = list(args)

   451

        self.CurrentInstance = None

   452

        self.CurrentConnection = None

   453

        self.CurrentLink = None

   454

   455

    def AddBlockInstance(self, context, *args):

   456

        specific_values_tuple, specific_values_translation = \

   457

            _SpecificValuesTuples.get(args[0][0], _BlockSpecificValues)

   458

   459

        if (args[0][0] == "step" and len(self.SpecificValues) < 3 or

   460

            args[0][0] == "transition" and len(self.SpecificValues) < 4):

   461

            self.SpecificValues.append([None])

   462

        elif args[0][0] == "actionBlock" and len(self.SpecificValues) < 1:

   463

            self.SpecificValues.append([[]])

   464

        specific_values = specific_values_tuple(*_translate_args(

   465

            specific_values_translation, self.SpecificValues))

   466

        self.SpecificValues = None

   467

   468

        self.CurrentInstance = _BlockInstanceInfos(

   469

            *(_translate_args([str] + [int] * 5, args) + 

   470

              [specific_values, [], []]))

   471

   472

        self.BlockInstances[self.CurrentInstance.id] = self.CurrentInstance

   473

   474

    def AddInstanceConnection(self, context, *args):

   475

        connection_args = _translate_args(

   476

            [str, str, _BoolValue, str, int, int], args)

   477

   478

        self.CurrentConnection = _InstanceConnectionInfos(

   479

            *(connection_args[1:4] + [

   480

                _Point(*connection_args[4:6]), []]))

   481

   482

        if self.CurrentInstance is not None:

   483

            if connection_args[0] == "input":

   484

                self.CurrentInstance.inputs.append(self.CurrentConnection)

   485

            else:

   486

                self.CurrentInstance.outputs.append(self.CurrentConnection)

   487

        else:

   488

            self.SpecificValues.append([self.CurrentConnection])

   489

   490

    def AddConnectionLink(self, context, *args):

   491

        self.CurrentLink = _ConnectionLinkInfos(

   492

            *(_translate_args([int, str], args) + [[]]))

   493

        self.CurrentConnection.links.append(self.CurrentLink)

   494

   495

    def AddLinkPoint(self, context, *args):

   496

        self.CurrentLink.points.append(_Point(

   497

            *_translate_args([int, int], args)))

   498

   499

    def AddAction(self, context, *args):

   500

        if len(self.SpecificValues) == 0: