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

   298

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

   299

    def __init__(self, controller):

   300

        self.Instances = []

   305

   306

    def AddInstance(self, context, *args):

   307

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

   308

   309

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

   311

        res = self.Instances

   312

        self.Instances = []

   313

        return res

   314

   315

class InstanceTagName(object):

   316

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

   317

   318

    def __init__(self, controller):

   319

        self.Controller = controller

   320

        self.TagName = None

   321

   322

    def GetTagName(self):

   323

        return self.TagName

   324

   325

    def ConfigTagName(self, context, *args):

   326

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

   327

   328

    def ResourceTagName(self, context, *args):

   329

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

   330

   331

    def PouTagName(self, context, *args):

   332

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

   333

   334

    def ActionTagName(self, context, *args):

   335

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

   336

   337

    def TransitionTagName(self, context, *args):

   338

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

   339

   340

   341

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

   342

#           Helpers object for generating pou block instances list

   343

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

   344

   345

   346

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

   347

   348

_BlockInstanceInfos = namedtuple(

   349

    "BlockInstanceInfos",

   350

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

   351

   352

_BlockSpecificValues = (

   353

    namedtuple("BlockSpecificValues",

   354

               ["name", "execution_order"]),

   355

    [_StringValue, int])

   356

_VariableSpecificValues = (

   357

    namedtuple("VariableSpecificValues",

   358

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

   359

    [_StringValue, _StringValue, int])

   360

_ConnectionSpecificValues = (

   361

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

   362

    [_StringValue])

   363

   364

_PowerRailSpecificValues = (

   365

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

   366

    [int])

   367

   368

_LDElementSpecificValues = (

   369

    namedtuple("LDElementSpecificValues",

   370

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

   371

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

   372

   373

_DivergenceSpecificValues = (

   374

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

   375

    [int])

   376

   377

_SpecificValuesTuples = {

   378

    "comment": (

   379

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

   380

        [_StringValue]),

   381

    "input": _VariableSpecificValues,

   382

    "output": _VariableSpecificValues,

   383

    "inout": _VariableSpecificValues,

   384

    "connector": _ConnectionSpecificValues,

   385

    "continuation": _ConnectionSpecificValues,

   386

    "leftPowerRail": _PowerRailSpecificValues,

   387

    "rightPowerRail": _PowerRailSpecificValues,

   388

    "contact": _LDElementSpecificValues,

   389

    "coil": _LDElementSpecificValues,

   390

    "step": (

   391

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

   392

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

   393

    "transition": (

   394

        namedtuple("TransitionSpecificValues",

   395

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

   396

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

   397

    "selectionDivergence": _DivergenceSpecificValues,

   398

    "selectionConvergence": _DivergenceSpecificValues,

   399

    "simultaneousDivergence": _DivergenceSpecificValues,

   400

    "simultaneousConvergence": _DivergenceSpecificValues,

   401

    "jump": (

   402

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

   403

        [_StringValue]),

   404

    "actionBlock": (

   405

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

   406

        [lambda x: x]),

   407

}

   408

   409

_InstanceConnectionInfos = namedtuple(

   410

    "InstanceConnectionInfos",

   411

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

   412

   413

_ConnectionLinkInfos = namedtuple(

   414

    "ConnectionLinkInfos",

   415

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

   416

   417

   418

class _ActionInfos(object):

   419

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

   420

   421

    def __init__(self, *args):

   422

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

   423

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

   424

   425

    def copy(self):

   426

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

   427

   428

   429

class BlockInstanceFactory(object):

   430

   431

    def __init__(self, block_instances):

   432

        self.BlockInstances = block_instances

   433

        self.CurrentInstance = None

   434

        self.SpecificValues = None

   435

        self.CurrentConnection = None

   436

        self.CurrentLink = None

   437

   438

    def SetSpecificValues(self, context, *args):

   439

        self.SpecificValues = list(args)

   440

        self.CurrentInstance = None

   441

        self.CurrentConnection = None

   442

        self.CurrentLink = None

   443

   444

    def AddBlockInstance(self, context, *args):

   445

        specific_values_tuple, specific_values_translation = \

   446

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

   447

   448

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

   449

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

   450

            self.SpecificValues.append([None])

   451

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

   452

            self.SpecificValues.append([[]])

   453

        specific_values = specific_values_tuple(*_translate_args(

   454

            specific_values_translation, self.SpecificValues))

   455

        self.SpecificValues = None

   456

   457

        self.CurrentInstance = _BlockInstanceInfos(

   458

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

   459

              [specific_values, [], []]))

   460

   461

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

   462

   463

    def AddInstanceConnection(self, context, *args):

   464

        connection_args = _translate_args(

   465

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

   466

   467

        self.CurrentConnection = _InstanceConnectionInfos(

   468

            *(connection_args[1:4] + [

   469

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

   470

   471

        if self.CurrentInstance is not None:

   472

            if connection_args[0] == "input":

   473

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

   474

            else:

   475

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

   476

        else:

   477

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

   478

   479

    def AddConnectionLink(self, context, *args):

   480

        self.CurrentLink = _ConnectionLinkInfos(

   481

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

   482

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

   483

   484

    def AddLinkPoint(self, context, *args):