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):

   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

   287

   288

    def AddInstance(self, context, *args):

   289

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

   290

   299

   300

class InstanceTagName(object):

   301

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

   302

   303

    def __init__(self, controller):

   304

        self.Controller = controller

   305

        self.TagName = None

   306

   307

    def GetTagName(self):

   308

        return self.TagName

   309

   310

    def ConfigTagName(self, context, *args):

   311

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

   312

   313

    def ResourceTagName(self, context, *args):

   314

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

   315

   316

    def PouTagName(self, context, *args):

   317

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

   318

   319

    def ActionTagName(self, context, *args):

   320

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

   321

   322

    def TransitionTagName(self, context, *args):

   323

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

   324

   325

   326

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

   327

#           Helpers object for generating pou block instances list

   328

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

   329

   330

   331

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

   332

   333

_BlockInstanceInfos = namedtuple(

   334

    "BlockInstanceInfos",

   335

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

   336

   337

_BlockSpecificValues = (

   338

    namedtuple("BlockSpecificValues",

   339

               ["name", "execution_order"]),

   340

    [_StringValue, int])

   341

_VariableSpecificValues = (

   342

    namedtuple("VariableSpecificValues",

   343

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

   344

    [_StringValue, _StringValue, int])

   345

_ConnectionSpecificValues = (

   346

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

   347

    [_StringValue])

   348

   349

_PowerRailSpecificValues = (

   350

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

   351

    [int])

   352

   353

_LDElementSpecificValues = (

   354

    namedtuple("LDElementSpecificValues",

   355

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

   356

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

   357

   358

_DivergenceSpecificValues = (

   359

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

   360

    [int])

   361

   362

_SpecificValuesTuples = {

   363

    "comment": (

   364

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

   365

        [_StringValue]),

   366

    "input": _VariableSpecificValues,

   367

    "output": _VariableSpecificValues,

   368

    "inout": _VariableSpecificValues,

   369

    "connector": _ConnectionSpecificValues,

   370

    "continuation": _ConnectionSpecificValues,

   371

    "leftPowerRail": _PowerRailSpecificValues,

   372

    "rightPowerRail": _PowerRailSpecificValues,

   373

    "contact": _LDElementSpecificValues,

   374

    "coil": _LDElementSpecificValues,

   375

    "step": (

   376

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

   377

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

   378

    "transition": (

   379

        namedtuple("TransitionSpecificValues",

   380

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

   381

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

   382

    "selectionDivergence": _DivergenceSpecificValues,

   383

    "selectionConvergence": _DivergenceSpecificValues,

   384

    "simultaneousDivergence": _DivergenceSpecificValues,

   385

    "simultaneousConvergence": _DivergenceSpecificValues,

   386

    "jump": (

   387

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

   388

        [_StringValue]),

   389

    "actionBlock": (

   390

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

   391

        [lambda x: x]),

   392

}

   393

   394

_InstanceConnectionInfos = namedtuple(

   395

    "InstanceConnectionInfos",

   396

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

   397

   398

_ConnectionLinkInfos = namedtuple(

   399

    "ConnectionLinkInfos",

   400

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

   401

   402

   403

class _ActionInfos(object):

   404

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

   405

   406

    def __init__(self, *args):

   407

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

   408

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

   409

   410

    def copy(self):

   411

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

   412

   413

   414

class BlockInstanceFactory(object):

   415

   416

    def __init__(self, block_instances):

   417

        self.BlockInstances = block_instances

   418

        self.CurrentInstance = None

   419

        self.SpecificValues = None

   420

        self.CurrentConnection = None

   421

        self.CurrentLink = None

   422

   423

    def SetSpecificValues(self, context, *args):

   424

        self.SpecificValues = list(args)

   425

        self.CurrentInstance = None

   426

        self.CurrentConnection = None

   427

        self.CurrentLink = None

   428

   429

    def AddBlockInstance(self, context, *args):

   430

        specific_values_tuple, specific_values_translation = \

   431

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

   432

   433

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

   434

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

   435

            self.SpecificValues.append([None])

   436

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

   437

            self.SpecificValues.append([[]])

   438

        specific_values = specific_values_tuple(*_translate_args(

   439

            specific_values_translation, self.SpecificValues))

   440

        self.SpecificValues = None

   441

   442

        self.CurrentInstance = _BlockInstanceInfos(

   443

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

   444

              [specific_values, [], []]))

   445

   446

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

   447

   448

    def AddInstanceConnection(self, context, *args):

   449

        connection_args = _translate_args(

   450

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

   451

   452

        self.CurrentConnection = _InstanceConnectionInfos(

   453

            *(connection_args[1:4] + [

   454

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

   455

   456

        if self.CurrentInstance is not None:

   457

            if connection_args[0] == "input":

   458

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

   459

            else:

   460

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

   461

        else:

   462

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

   463

   464

    def AddConnectionLink(self, context, *args):

   465

        self.CurrentLink = _ConnectionLinkInfos(

   466

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

   467

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

   468

   469

    def AddLinkPoint(self, context, *args):

   470

        self.CurrentLink.points.append(_Point(

   471

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

   472

   473

    def AddAction(self, context, *args):

   474

        if len(self.SpecificValues) == 0:

   475

            self.SpecificValues.append([[]])

   476

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

   477

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

   478

   479

   480

pou_block_instances_xslt = etree.parse(

   481

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

   482

   483

   484

# Length of the buffer