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

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

   104

#                 Helpers object for generating pou var list

   105

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

   106

   107

def compute_dimensions(el):

   108

    return [

   109

        (dimension.get("lower"), dimension.get("upper"))

   110

        for dimension in el.findall("dimension")]

   111

   112

def extract_param(el):

   113

    if el.tag == "Type" and el.text is None:

   114

        array = el.find("array")

   115

        return ('array', array.text, compute_dimensions(array))

   116

    elif el.tag == "Tree":

   117

        return generate_var_tree(el)

   118

    elif el.tag == "Edit":

   119

        return el.text == "True"

   120

    elif el.text is None:

   121

        return ''

   122

    return el.text

   123

   124

def generate_var_tree(tree):

   125

    return ([

   126

        (var.get("name"), var.text, generate_var_tree(var))

   127

         for var in tree.findall("var")],

   128

        compute_dimensions(tree))

   129

   130

class AddVariable(etree.XSLTExtension):

   131

   132

    def __init__(self, variables):

   133

        etree.XSLTExtension.__init__(self)

   134

        self.Variables = variables

   135

   136

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

   137

        infos = etree.Element('var_infos')

   138

        self.process_children(context, infos)

   139

        self.Variables.append(

   140

            {el.tag.replace("_", " "): extract_param(el) for el in infos})

   141

   142

class VarTree(etree.XSLTExtension):

   143

   144

    def __init__(self, controller, debug):

   145

        etree.XSLTExtension.__init__(self)

   146

        self.Controller = controller

   147

        self.Debug = debug

   148

   149

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

   150

        typename = input_node.get("name")

   151

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

   152

        if pou_infos is not None:

   153

            self.apply_templates(context, pou_infos, output_parent)

   154

            return

   155

   156

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

   157

        if datatype_infos is not None:

   158

            self.apply_templates(context, datatype_infos, output_parent)

   159

            return

   160

   161

class VarIsEdited(etree.XSLTExtension):

   162

   163

    def __init__(self, controller, debug):

   164

        etree.XSLTExtension.__init__(self)

   165

        self.Controller = controller

   166

        self.Debug = debug

   167

   168

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

   169

        typename = input_node.get("name")

   170

        output_parent.text = str(

   171

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

   172

   173

variables_infos_xslt = etree.parse(

   174

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

   175

   176

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

   177

#            Helpers object for generating pou variable instance list

   178

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

   179

   180

def class_extraction(el, prt):

   181

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

   182

        pou_type = POU_TYPES.get(el.text)

   183

        if pou_type is not None:

   184

            return pou_type

   185

        return VAR_CLASS_INFOS[el.text][1]

   186

    return {

   187

        "configuration": ITEM_CONFIGURATION,

   188

        "resource": ITEM_RESOURCE,

   189

        "action": ITEM_ACTION,

   190

        "transition": ITEM_TRANSITION,

   191

        "program": ITEM_PROGRAM}.get(prt)

   192

   193

PARAM_VALUE_EXTRACTION = {

   194

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

   195

    "class": class_extraction,

   196

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

   197

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

   198

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

   199

    "variables": lambda el, prt: [

   200

        compute_instance_tree(chld)

   201

        for chld in el]}

   202

   203

def compute_instance_tree(tree):

   204

    return {el.tag:

   205

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

   206

        for el in tree}

   207

   208

class IsEdited(etree.XSLTExtension):

   209

   210

    def __init__(self, controller, debug):

   211

        etree.XSLTExtension.__init__(self)

   212

        self.Controller = controller

   213

        self.Debug = debug

   214

   215

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

   216

        typename = input_node.get("name")

   217

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

   218

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

   219

   220

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

        pou_infos = project.getpou(typename)

   231

        if pou_infos is not None:

   232

            self.apply_templates(context, pou_infos, output_parent)

   233

            return

   234

   235

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

   236

        if datatype_infos is not None:

   237

            self.apply_templates(context, datatype_infos, output_parent)

   238

            return

   239

   240

        output_parent.text = "False"

   241

   242

class PouVariableClass(etree.XSLTExtension):

   243

   244

    def __init__(self, controller, debug):

   245

        etree.XSLTExtension.__init__(self)

   246

        self.Controller = controller

   247

        self.Debug = debug

   248

   249

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

   250

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

   251

        if pou_infos is not None:

   252

            self.apply_templates(context, pou_infos, output_parent)

   253

            return

   254

   255

        self.process_children(context, output_parent)

   256

   257

pou_variables_xslt = etree.parse(

   258

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

   259

   260

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

   261

#            Helpers object for generating instances path list

   262

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

   263

   264

class InstanceDefinition(etree.XSLTExtension):

   265

   266

    def __init__(self, controller, debug):

   267

        etree.XSLTExtension.__init__(self)

   268

        self.Controller = controller

   269

        self.Debug = debug

   270

   271

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

   272

        instance_infos = etree.Element('infos')

   273

        self.process_children(context, instance_infos)

   274

   275

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

   276

        if pou_infos is not None:

   277

            pou_instance = etree.Element('pou_instance',

   278

                pou_path=instance_infos.get("path"))

   279

            pou_instance.append(deepcopy(pou_infos))

   280

            self.apply_templates(context, pou_instance, output_parent)

   281

            return

   282

   283

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

   284

        if datatype_infos is not None:

   285

            datatype_instance = etree.Element('datatype_instance',

   286

                datatype_path=instance_infos.get("path"))

   287

            datatype_instance.append(deepcopy(datatype_infos))

   288

            self.apply_templates(context, datatype_instance, output_parent)

   289

            return

   290

   291

instances_path_xslt = etree.parse(

   292

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

   293

   294

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

   295

#            Helpers object for generating instance tagname

   296

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

   297

   298

class InstanceTagName(etree.XSLTExtension):

   299

   300

    def __init__(self, controller):

   301

        etree.XSLTExtension.__init__(self)

   302

        self.Controller = controller

   303

   304

    def GetTagName(self, infos):

   305

        return ""

   306

   307

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

   308

        tagname_infos = etree.Element('infos')

   309

        self.process_children(context, tagname_infos)

   310

        tagname = etree.Element('tagname')

   311

        tagname.text = self.GetTagName(tagname_infos)

   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

#           Helpers object for generating pou block instances list

   350

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

   351

   352

_BoolValue = lambda x: x in ["true", "0"]

   353

   354

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

   355

   356

_BlockInstanceInfos = namedtuple("BlockInstanceInfos", 

   357

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

   358

   359

_BlockSpecificValues = (

   360

    namedtuple("BlockSpecificValues", 

   361

               ["name", "execution_order"]),

   362

    [str, int])

   363

_VariableSpecificValues = (

   364

    namedtuple("VariableSpecificValues", 

   365

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

   366

    [str, str, int])

   367

_ConnectionSpecificValues = (

   368

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

   369

    [str])

   370

   371

_PowerRailSpecificValues = (

   372

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

   373

    [int])

   374

   375

_LDElementSpecificValues = (

   376

    namedtuple("LDElementSpecificValues", 

   377

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

   378

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

   379

   380

_DivergenceSpecificValues = (

   381

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

   382

    [int])

   383

   384

_SpecificValuesTuples = {

   385

    "comment": (

   386

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

   387

        [str]),

   388

    "input": _VariableSpecificValues,

   389

    "output": _VariableSpecificValues,

   390

    "inout": _VariableSpecificValues,

   391

    "connector": _ConnectionSpecificValues,

   392

    "continuation": _ConnectionSpecificValues,

   393

    "leftPowerRail": _PowerRailSpecificValues,

   394

    "rightPowerRail": _PowerRailSpecificValues,

   395

    "contact": _LDElementSpecificValues,

   396

    "coil": _LDElementSpecificValues,

   397

    "step": (

   398

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

   399

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

   400

    "transition": (

   401

        namedtuple("TransitionSpecificValues", 

   402

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

   403

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

   404

    "selectionDivergence": _DivergenceSpecificValues,

   405

    "selectionConvergence": _DivergenceSpecificValues,

   406

    "simultaneousDivergence": _DivergenceSpecificValues,

   407

    "simultaneousConvergence": _DivergenceSpecificValues,

   408

    "jump": (

   409

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

   410

        [str]),

   411

    "actionBlock": (

   412

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

   413

        [lambda x: x]),

   414

}

   415

   416

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   417

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

   418

   419

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   420

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

   421

   429

   430

def _translate_args(translations, args):

   431

    return [translate(arg[0]) if len(arg) > 0 else None 

   432

            for translate, arg in

   433

            zip(translations, args)]

   434

   435

class BlockInstanceFactory:

   436

   437

    def __init__(self, block_instances):

   438

        self.BlockInstances = block_instances

   439

        self.CurrentInstance = None

   440

        self.SpecificValues = None

   441

        self.CurrentConnection = None

   442

        self.CurrentLink = None

   443

   444

    def SetSpecificValues(self, context, *args):

   445

        self.SpecificValues = list(args)

   446

        self.CurrentInstance = None

   447

        self.CurrentConnection = None

   448

        self.CurrentLink = None

   449

   450

    def AddBlockInstance(self, context, *args):

   451

        specific_values_tuple, specific_values_translation = \

   452

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

   453

   454

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

   455

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

   456

            self.SpecificValues.append([None])

   457

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

   458

            self.SpecificValues.append([[]])

   459

        specific_values = specific_values_tuple(*_translate_args(

   460

            specific_values_translation, self.SpecificValues))

   461

        self.SpecificValues = None

   462

   463

        self.CurrentInstance = _BlockInstanceInfos(

   464

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

   465

              [specific_values, [], []]))

   466

   467

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

   468

   469

    def AddInstanceConnection(self, context, *args):

   470

        connection_args = _translate_args(

   471

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

   472

   473

        self.CurrentConnection = _InstanceConnectionInfos(

   474

            *(connection_args[1:4] + [

   475

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

   476

   477

        if self.CurrentInstance is not None:

   478

            if connection_args[0] == "input":

   479

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

   480

            else:

   481

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

   482

        else:

   483

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

   484

   485

    def AddConnectionLink(self, context, *args):

   486

        self.CurrentLink = _ConnectionLinkInfos(

   487

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

   488

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

   489

   490

    def AddLinkPoint(self, context, *args):

   491

        self.CurrentLink.points.append(_Point(

   492

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

   493

   494

    def AddAction(self, context, *args):

   495

        if len(self.SpecificValues) == 0:

   496

            self.SpecificValues.append([[]])

   497

        translated_args = _translate_args([str] * 5, args)

   498

        self.SpecificValues[0][0].append(_ActionInfos(*translated_args))

   499

   500

pou_block_instances_xslt = etree.parse(