1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

# This program is free software; you can redistribute it and/or

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

# of the License, or (at your option) any later version.

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

# You should have received a copy of the GNU General Public License

    23

# along with this program; if not, write to the Free Software

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

    27

from __future__ import absolute_import

    28

from types import TupleType

    29

from copy import deepcopy

    30

import os

    31

import re

    32

import datetime

    33

from time import localtime

    34

from collections import OrderedDict, namedtuple

    35

    36

from lxml import etree

    37

    38

import util.paths as paths

    39

from util.TranslationCatalogs import NoTranslate

    40

from plcopen import *

    41

from graphics.GraphicCommons import *

    42

from PLCGenerator import *

    43

    44

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

    45

    46

ITEMS_EDITABLE = [

    47

    ITEM_PROJECT,

    48

    ITEM_POU,

    49

    ITEM_VARIABLE,

    50

    ITEM_TRANSITION,

    51

    ITEM_ACTION,

    52

    ITEM_CONFIGURATION,

    53

    ITEM_RESOURCE,

    54

    ITEM_DATATYPE

    55

] = range(8)

    56

    57

ITEMS_UNEDITABLE = [

    58

    ITEM_DATATYPES,

    59

    ITEM_FUNCTION,

    60

    ITEM_FUNCTIONBLOCK,

    61

    ITEM_PROGRAM,

    62

    ITEM_TRANSITIONS,

    63

    ITEM_ACTIONS,

    64

    ITEM_CONFIGURATIONS,

    65

    ITEM_RESOURCES,

    66

    ITEM_PROPERTIES

    67

] = range(8, 17)

    68

    69

ITEMS_VARIABLE = [

    70

    ITEM_VAR_LOCAL,

    71

    ITEM_VAR_GLOBAL,

    72

    ITEM_VAR_EXTERNAL,

    73

    ITEM_VAR_TEMP,

    74

    ITEM_VAR_INPUT,

    75

    ITEM_VAR_OUTPUT,

    76

    ITEM_VAR_INOUT

    77

] = range(17, 24)

    78

    79

VAR_CLASS_INFOS = {

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

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

    87

    88

POU_TYPES = {

    89

    "program": ITEM_PROGRAM,

    90

    "functionBlock": ITEM_FUNCTIONBLOCK,

    91

    "function": ITEM_FUNCTION,

    92

}

    93

    94

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    95

                   LOCATION_MODULE,

    96

                   LOCATION_GROUP,

    97

                   LOCATION_VAR_INPUT,

    98

                   LOCATION_VAR_OUTPUT,

    99

                   LOCATION_VAR_MEMORY] = range(6)

   100

   101

ScriptDirectory = paths.AbsDir(__file__)

   102

   103

   104

def GetUneditableNames():

   105

    _ = NoTranslate

   106

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

   107

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

   108

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

   109

   110

   111

UNEDITABLE_NAMES = GetUneditableNames()

   112

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   113

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   114

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   115

   116

   117

class LibraryResolver(etree.Resolver):

   118

    """Helper object for loading library in xslt stylesheets"""

   119

   120

    def __init__(self, controller, debug=False):

   121

        self.Controller = controller

   122

        self.Debug = debug

   123

   124

    def resolve(self, url, pubid, context):

   125

        # TODO stop deepcopy

   126

        lib_name = os.path.basename(url)

   127

        if lib_name in ["project", "stdlib", "extensions"]:

   128

            lib_el = etree.Element(lib_name)

   129

            if lib_name == "project":

   130

                lib_el.append(deepcopy(self.Controller.GetProject(self.Debug)))

   131

            elif lib_name == "stdlib":

   132

                for lib in StdBlckLibs.values():

   133

                    lib_el.append(deepcopy(lib))

   134

            else:

   135

                for ctn in self.Controller.ConfNodeTypes:

   136

                    lib_el.append(deepcopy(ctn["types"]))

   137

            return self.resolve_string(etree.tostring(lib_el), context)

   138

   139

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

   140

#           Helpers functions for translating list of arguments

   141

#                       from xslt to valid arguments

   142

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

   143

   144

   145

def _StringValue(x):

   146

    return x

   147

   148

   149

def _BoolValue(x):

   150

    return x in ["true", "0"]

   151

   152

   153

def _translate_args(translations, args):

   154

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

   155

            for translate, arg in

   156

            zip(translations, args)]

   157

   158

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

   159

#                 Helpers object for generating pou var list

   160

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

   161

   162

   163

class _VariableInfos(object):

   164

    __slots__ = ["Name", "Class", "Option", "Location", "InitialValue",

   165

                 "Edit", "Documentation", "Type", "Tree", "Number"]

   166

   167

    def __init__(self, *args):

   168

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

   169

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

   170

   171

    def copy(self):

   172

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

   173

   174

   175

class VariablesInfosFactory(object):

   176

   177

    def __init__(self, variables):

   178

        self.Variables = variables

   179

        self.TreeStack = []

   180

        self.Type = None

   181

        self.Dimensions = None

   182

   183

    def SetType(self, context, *args):

   184

        self.Type = args[0][0]

   185

   186

    def GetType(self):

   187

        if len(self.Dimensions) > 0:

   188

            return ("array", self.Type, self.Dimensions)

   189

        return self.Type

   190

   191

    def GetTree(self):

   192

        return (self.TreeStack.pop(-1), self.Dimensions)

   193

   194

    def AddDimension(self, context, *args):

   195

        self.Dimensions.append(tuple(

   196

            _translate_args([_StringValue] * 2, args)))

   197

   198

    def AddTree(self, context, *args):

   199

        self.TreeStack.append([])

   200

        self.Dimensions = []

   201

   202

    def AddVarToTree(self, context, *args):

   203

        var = (args[0][0], self.Type, self.GetTree())

   204

        self.TreeStack[-1].append(var)

   205

   206

    def AddVariable(self, context, *args):

   207

        self.Variables.append(_VariableInfos(*(

   208

            _translate_args([_StringValue] * 5 + [_BoolValue] + [_StringValue], args) +

   209

            [self.GetType(), self.GetTree()])))

   210

   211

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

   212

#            Helpers object for generating pou variable instance list

   213

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

   214

   215

   216

def class_extraction(value):

   217

    class_type = {

   218

        "configuration": ITEM_CONFIGURATION,

   219

        "resource": ITEM_RESOURCE,

   220

        "action": ITEM_ACTION,

   221

        "transition": ITEM_TRANSITION,

   222

        "program": ITEM_PROGRAM}.get(value)

   223

    if class_type is not None:

   224

        return class_type

   225

   226

    pou_type = POU_TYPES.get(value)

   227

    if pou_type is not None:

   228

        return pou_type

   229

   230

    var_type = VAR_CLASS_INFOS.get(value)

   231

    if var_type is not None:

   232

        return var_type[1]

   233

   234

    return None

   235

   236

   237

class _VariablesTreeItemInfos(object):

   238

    __slots__ = ["name", "var_class", "type", "edit", "debug", "variables"]

   239

   240

    def __init__(self, *args):

   241

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

   242

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

   243

   244

    def copy(self):

   245

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

   246

   247

   248

class VariablesTreeInfosFactory(object):

   249

   250

    def __init__(self):

   251

        self.Root = None

   252

   253

    def GetRoot(self):

   254

        return self.Root

   255

   256

    def SetRoot(self, context, *args):

   257

        self.Root = _VariablesTreeItemInfos(

   258

            *([''] + _translate_args(

   259

                [class_extraction, _StringValue] + [_BoolValue] * 2,

   260

                args) + [[]]))

   261

   262

    def AddVariable(self, context, *args):

   263

        if self.Root is not None:

   264

            self.Root.variables.append(_VariablesTreeItemInfos(

   265

                *(_translate_args(

   266

                    [_StringValue, class_extraction, _StringValue] +

   267

                    [_BoolValue] * 2, args) + [[]])))

   268

   269

   270

class InstancesPathCollector(object):

   271

    """ object for collecting instances path list"""

   272

    def __init__(self, controller):

   273

        self.Instances = []

   275

        parser = etree.XMLParser()

   276

        # arbitrary set debug to false, updated later

   278

   279

        # TODO compile XSLT once for all at __init__

   280

        self.instances_path_xslt_tree = etree.XSLT(

   281

            etree.parse(

   282

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

   283

                parser),

   284

            extensions={

   289

   290

    def AddInstance(self, context, *args):

   291

        self.Instances.append(args[0][0])

   292

   302

    def Collect(self, root, name, debug):

   304

        self.instances_path_xslt_tree(

   305

            root, instance_type=etree.XSLT.strparam(name))

   306

        res = self.Instances

   307

        self.Instances = []

   308

        return res

   309

   310

   311

class InstanceTagName(object):

   312

    """Helpers object for generating instance tagname"""

   313

   314

    def __init__(self, controller):

   315

        self.Controller = controller

   316

        self.TagName = None

   317

   318

    def GetTagName(self):

   319

        return self.TagName

   320

   321

    def ConfigTagName(self, context, *args):

   322

        self.TagName = self.Controller.ComputeConfigurationName(args[0][0])

   323

   324

    def ResourceTagName(self, context, *args):

   325

        self.TagName = self.Controller.ComputeConfigurationResourceName(args[0][0], args[1][0])

   326

   327

    def PouTagName(self, context, *args):

   328

        self.TagName = self.Controller.ComputePouName(args[0][0])

   329

   330

    def ActionTagName(self, context, *args):

   331

        self.TagName = self.Controller.ComputePouActionName(args[0][0], args[0][1])

   332

   333

    def TransitionTagName(self, context, *args):

   334

        self.TagName = self.Controller.ComputePouTransitionName(args[0][0], args[0][1])

   335

   336

   337

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

   338

#           Helpers object for generating pou block instances list

   339

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

   340

   341

   342

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

   343

   344

_BlockInstanceInfos = namedtuple(

   345

    "BlockInstanceInfos",

   346

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

   347

   348

_BlockSpecificValues = (

   349

    namedtuple("BlockSpecificValues",

   350

               ["name", "execution_order"]),

   351

    [_StringValue, int])

   352

_VariableSpecificValues = (

   353

    namedtuple("VariableSpecificValues",

   354

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

   355

    [_StringValue, _StringValue, int])

   356

_ConnectionSpecificValues = (

   357

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

   358

    [_StringValue])

   359

   360

_PowerRailSpecificValues = (

   361

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

   362

    [int])

   363

   364

_LDElementSpecificValues = (

   365

    namedtuple("LDElementSpecificValues",

   366

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

   367

    [_StringValue, _BoolValue, _StringValue, _StringValue, int])

   368

   369

_DivergenceSpecificValues = (

   370

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

   371

    [int])

   372

   373

_SpecificValuesTuples = {

   374

    "comment": (

   375

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

   376

        [_StringValue]),

   377

    "input": _VariableSpecificValues,

   378

    "output": _VariableSpecificValues,

   379

    "inout": _VariableSpecificValues,

   380

    "connector": _ConnectionSpecificValues,

   381

    "continuation": _ConnectionSpecificValues,

   382

    "leftPowerRail": _PowerRailSpecificValues,

   383

    "rightPowerRail": _PowerRailSpecificValues,

   384

    "contact": _LDElementSpecificValues,

   385

    "coil": _LDElementSpecificValues,

   386

    "step": (

   387

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

   388

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

   389

    "transition": (

   390

        namedtuple("TransitionSpecificValues",

   391

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

   392

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

   393

    "selectionDivergence": _DivergenceSpecificValues,

   394

    "selectionConvergence": _DivergenceSpecificValues,

   395

    "simultaneousDivergence": _DivergenceSpecificValues,

   396

    "simultaneousConvergence": _DivergenceSpecificValues,

   397

    "jump": (

   398

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

   399

        [_StringValue]),

   400

    "actionBlock": (

   401

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

   402

        [lambda x: x]),

   403

}

   404

   405

_InstanceConnectionInfos = namedtuple(

   406

    "InstanceConnectionInfos",

   407

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

   408

   409

_ConnectionLinkInfos = namedtuple(

   410

    "ConnectionLinkInfos",

   411

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

   412

   413

   414

class _ActionInfos(object):

   415

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

   416

   417

    def __init__(self, *args):

   418

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

   419

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

   420

   421

    def copy(self):

   422

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

   423

   424

   425

class BlockInstanceFactory(object):

   426

   427

    def __init__(self, block_instances):

   428

        self.BlockInstances = block_instances

   429

        self.CurrentInstance = None

   430

        self.SpecificValues = None

   431

        self.CurrentConnection = None

   432

        self.CurrentLink = None

   433

   434

    def SetSpecificValues(self, context, *args):

   435

        self.SpecificValues = list(args)

   436

        self.CurrentInstance = None

   437

        self.CurrentConnection = None

   438

        self.CurrentLink = None

   439

   440

    def AddBlockInstance(self, context, *args):

   441

        specific_values_tuple, specific_values_translation = \

   442

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

   443

   444

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

   445

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

   446

            self.SpecificValues.append([None])

   447

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

   448

            self.SpecificValues.append([[]])

   449

        specific_values = specific_values_tuple(*_translate_args(

   450

            specific_values_translation, self.SpecificValues))

   451

        self.SpecificValues = None

   452

   453

        self.CurrentInstance = _BlockInstanceInfos(

   454

            *(_translate_args([_StringValue, int] + [float] * 4, args) +

   455

              [specific_values, [], []]))

   456

   457

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

   458

   459

    def AddInstanceConnection(self, context, *args):

   460

        connection_args = _translate_args(

   461

            [_StringValue] * 2 + [_BoolValue, _StringValue] + [float] * 2, args)

   462

   463

        self.CurrentConnection = _InstanceConnectionInfos(

   464

            *(connection_args[1:4] + [

   465

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

   466

   467

        if self.CurrentInstance is not None:

   468

            if connection_args[0] == "input":

   469

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

   470

            else:

   471

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

   472

        else:

   473

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

   474

   475

    def AddConnectionLink(self, context, *args):

   476

        self.CurrentLink = _ConnectionLinkInfos(

   477

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

   478

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

   479

   480

    def AddLinkPoint(self, context, *args):

   481

        self.CurrentLink.points.append(_Point(

   482

            *_translate_args([float] * 2, args)))

   483

   484

    def AddAction(self, context, *args):