1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz

     5

# Copyright (C) 2019: Edouard TISSERANT

     6

#

     7

# See COPYING file for copyrights details.

     8

     9

from __future__ import absolute_import

    10

import os

    11

import shutil

    12

from itertools import izip, imap

    13

from pprint import pformat

    14

import hashlib

    15

import weakref

    16

import shlex

    17

import time

    18

    19

import wx

    20

    21

from lxml import etree

    22

from lxml.etree import XSLTApplyError

    23

    24

import util.paths as paths

    25

from POULibrary import POULibrary

    26

from docutil import open_svg, get_inkscape_path

    27

    28

from util.ProcessLogger import ProcessLogger

    29

from runtime.typemapping import DebugTypesSize

    30

import targets

    31

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    32

from XSLTransform import XSLTransform

    33

from svghmi.i18n import EtreeToMessages, SaveCatalog, ReadTranslations, MatchTranslations, TranslationToEtree, open_pofile

    34

    35

HMI_TYPES_DESC = {

    36

    "HMI_NODE":{},

    37

    "HMI_STRING":{},

    38

    "HMI_INT":{},

    39

    "HMI_BOOL":{},

    40

    "HMI_REAL":{}

    41

}

    42

    43

HMI_TYPES = HMI_TYPES_DESC.keys()

    44

    45

    46

ScriptDirectory = paths.AbsDir(__file__)

    47

    48

class HMITreeNode(object):

    49

    def __init__(self, path, name, nodetype, iectype = None, vartype = None, cpath = None, hmiclass = None):

    50

        self.path = path

    51

        self.name = name

    52

        self.nodetype = nodetype

    53

        self.hmiclass = hmiclass

    54

    55

        if iectype is not None:

    56

            self.iectype = iectype

    57

            self.vartype = vartype

    58

            self.cpath = cpath

    59

    60

        if nodetype in ["HMI_NODE"]:

    61

            self.children = []

    62

    63

    def pprint(self, indent = 0):

    64

        res = ">"*indent + pformat(self.__dict__, indent = indent, depth = 1) + "\n"

    65

        if hasattr(self, "children"):

    66

            res += "\n".join([child.pprint(indent = indent + 1)

    67

                              for child in self.children])

    68

            res += "\n"

    69

    70

        return res

    71

    72

    def place_node(self, node):

    73

        best_child = None

    74

        known_best_match = 0

    75

        potential_siblings = {}

    76

        for child in self.children:

    77

            if child.path is not None:

    78

                in_common = 0

    79

                for child_path_item, node_path_item in izip(child.path, node.path):

    80

                    if child_path_item == node_path_item:

    81

                        in_common +=1

    82

                    else:

    83

                        break

    84

                # Match can only be HMI_NODE, and the whole path of node

    85

                # must match candidate node (except for name part)

    86

                # since candidate would become child of that node

    87

                if in_common > known_best_match and \

    88

                   child.nodetype == "HMI_NODE" and \

    89

                   in_common == len(child.path) - 1:

    90

                    known_best_match = in_common

    91

                    best_child = child

    92

                else:

    93

                    potential_siblings[child.path[

    94

                        -2 if child.nodetype == "HMI_NODE" else -1]] = child

    95

        if best_child is not None:

    96

            if node.nodetype == "HMI_NODE" and best_child.path[:-1] == node.path[:-1]:

    97

                return "Duplicate_HMI_NODE", best_child

    98

            return best_child.place_node(node)

    99

        else:

   100

            candidate_name = node.path[-2 if node.nodetype == "HMI_NODE" else -1]

   101

            if candidate_name in potential_siblings:

   102

                return "Non_Unique", potential_siblings[candidate_name]

   103

   104

            if node.nodetype == "HMI_NODE" and len(self.children) > 0:

   105

                prev = self.children[-1]

   106

                if prev.path[:-1] == node.path[:-1]:

   107

                    return "Late_HMI_NODE",prev

   108

   109

            self.children.append(node)

   110

            return None

   111

   112

    def etree(self, add_hash=False):

   113

   114

        attribs = dict(name=self.name)

   115

        if self.path is not None:

   116

            attribs["path"] = ".".join(self.path)

   117

   118

        if self.hmiclass is not None:

   119

            attribs["class"] = self.hmiclass

   120

   121

        if add_hash:

   122

            attribs["hash"] = ",".join(map(str,self.hash()))

   123

   124

        res = etree.Element(self.nodetype, **attribs)

   125

   126

        if hasattr(self, "children"):

   127

            for child_etree in imap(lambda c:c.etree(), self.children):

   128

                res.append(child_etree)

   129

   130

        return res

   131

   132

    @classmethod

   133

    def from_etree(cls, enode):

   134

        """

   135

        alternative constructor, restoring HMI Tree from XML backup

   136

        note: all C-related information is gone, 

   137

              this restore is only for tree display and widget picking

   138

        """

   139

        nodetype = enode.tag

   140

        attributes = enode.attrib

   141

        name = attributes["name"]

   142

        path = attributes["path"].split('.') if "path" in attributes else None 

   143

        hmiclass = attributes.get("class", None)

   144

        # hash is computed on demand

   145

        node = cls(path, name, nodetype, hmiclass=hmiclass)

   146

        for child in enode.iterchildren():

   147

            node.children.append(cls.from_etree(child))

   148

        return node

   149

   150

    def traverse(self):

   151

        yield self

   152

        if hasattr(self, "children"):

   153

            for c in self.children:

   154

                for yoodl in c.traverse():

   155

                    yield yoodl

   156

   157

   158

    def hash(self):

   159

        """ Produce a hash, any change in HMI tree structure change that hash """

   160

        s = hashlib.new('md5')

   161

        self._hash(s)

   162

        # limit size to HMI_HASH_SIZE as in svghmi.c

   163

        return map(ord,s.digest())[:8]

   164

   165

    def _hash(self, s):

   166

        s.update(str((self.name,self.nodetype)))

   167

        if hasattr(self, "children"):

   168

            for c in self.children:

   169

                c._hash(s)

   170

   171

# module scope for HMITree root

   172

# so that CTN can use HMITree deduced in Library

   173

# note: this only works because library's Generate_C is

   174

#       systematicaly invoked before CTN's CTNGenerate_C

   175

   176

hmi_tree_root = None

   177

   178

on_hmitree_update = None

   179

   180

SPECIAL_NODES = [("HMI_ROOT", "HMI_NODE"),

   181

                 ("heartbeat", "HMI_INT")]

   182

                 # ("current_page", "HMI_STRING")])

   183

   184

class SVGHMILibrary(POULibrary):

   185

    def GetLibraryPath(self):

   186

         return paths.AbsNeighbourFile(__file__, "pous.xml")

   187

   188

    def Generate_C(self, buildpath, varlist, IECCFLAGS):

   189

        global hmi_tree_root, on_hmitree_update

   190

   191

        """

   192

        PLC Instance Tree:

   193

          prog0

   194

           +->v1 HMI_INT

   195

           +->v2 HMI_INT

   196

           +->fb0 (type mhoo)

   197

           |   +->va HMI_NODE

   198

           |   +->v3 HMI_INT

   199

           |   +->v4 HMI_INT

   200

           |

   201

           +->fb1 (type mhoo)

   202

           |   +->va HMI_NODE

   203

           |   +->v3 HMI_INT

   204

           |   +->v4 HMI_INT

   205

           |

   206

           +->fb2

   207

               +->v5 HMI_IN

   208

   209

        HMI tree:

   210

          hmi0

   211

           +->v1

   212

           +->v2

   213

           +->fb0 class:va

   214

           |   +-> v3

   215

           |   +-> v4

   216

           |

   217

           +->fb1 class:va

   218

           |   +-> v3

   219

           |   +-> v4

   220

           |

   221

           +->v5

   222

   223

        """

   224

   225

        # Filter known HMI types

   226

        hmi_types_instances = [v for v in varlist if v["derived"] in HMI_TYPES]

   227

   228

        hmi_tree_root = None

   229

   230

        # take first HMI_NODE (placed as special node), make it root

   231

        for i,v in enumerate(hmi_types_instances):

   232

            path = v["IEC_path"].split(".")

   233

            derived = v["derived"]

   234

            if derived == "HMI_NODE":

   235

                hmi_tree_root = HMITreeNode(path, "", derived, v["type"], v["vartype"], v["C_path"])

   236

                hmi_types_instances.pop(i)

   237

                break

   238

   239

        if hmi_tree_root is None:

   240

            self.FatalError("SVGHMI : Library is selected but not used. Please either deselect it in project config or add a SVGHMI node to project.")

   241

   242

        # deduce HMI tree from PLC HMI_* instances

   243

        for v in hmi_types_instances:

   244

            path = v["IEC_path"].split(".")

   245

            # ignores variables starting with _TMP_

   246

            if path[-1].startswith("_TMP_"):

   247

                continue

   248

            derived = v["derived"]

   249

            kwargs={}

   250

            if derived == "HMI_NODE":

   251

                # TODO : make problem if HMI_NODE used in CONFIG or RESOURCE

   252

                name = path[-2]

   253

                kwargs['hmiclass'] = path[-1]

   254

            else:

   255

                name = path[-1]

   256

            new_node = HMITreeNode(path, name, derived, v["type"], v["vartype"], v["C_path"], **kwargs)

   257

            placement_result = hmi_tree_root.place_node(new_node)

   258

            if placement_result is not None:

   259

                cause, problematic_node = placement_result

   260

                if cause == "Non_Unique":

   261

                    message = _("HMI tree nodes paths are not unique.\nConflicting variable: {} {}").format(

   262

                        ".".join(problematic_node.path),

   263

                        ".".join(new_node.path))

   264

   265

                    last_FB = None 

   266

                    for v in varlist:

   267

                        if v["vartype"] == "FB":

   268

                            last_FB = v 

   269

                        if v["C_path"] == problematic_node:

   270

                            break

   271

                    if last_FB is not None:

   272

                        failing_parent = last_FB["type"]

   273

                        message += "\n"

   274

                        message += _("Solution: Add HMI_NODE at beginning of {}").format(failing_parent)

   275

   276

                elif cause in ["Late_HMI_NODE", "Duplicate_HMI_NODE"]:

   277

                    cause, problematic_node = placement_result

   278

                    message = _("There must be only one occurrence of HMI_NODE before any HMI_* variable in POU.\nConflicting variable: {} {}").format(

   279

                        ".".join(problematic_node.path),

   280

                        ".".join(new_node.path))

   281

   282

                self.FatalError("SVGHMI : " + message)

   283

   284

        if on_hmitree_update is not None:

   285

            on_hmitree_update()

   286

   287

        variable_decl_array = []

   288

        extern_variables_declarations = []

   289

        buf_index = 0

   290

        item_count = 0

   291

        found_heartbeat = False

   292

   293

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   294

   295

        for node in hmi_tree_root.traverse():

   296

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   297

                hmi_tree_hearbeat_index = item_count

   298

                found_heartbeat = True

   299

                extern_variables_declarations += [

   300

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   301

                ]

   302

            if hasattr(node, "iectype"):

   303

                sz = DebugTypesSize.get(node.iectype, 0)

   304

                variable_decl_array += [

   305

                    "{&(" + node.cpath + "), " + node.iectype + {

   306

                        "EXT": "_P_ENUM",

   307

                        "IN":  "_P_ENUM",

   308

                        "MEM": "_O_ENUM",

   309

                        "OUT": "_O_ENUM",

   310

                        "VAR": "_ENUM"

   311

                    }[node.vartype] + ", " +

   312

                    str(buf_index) + ", 0, }"]

   313

                buf_index += sz

   314

                item_count += 1

   315

                if len(node.path) == 1:

   316

                    extern_variables_declarations += [

   317

                        "extern __IEC_" + node.iectype + "_" +

   318

                        "t" if node.vartype is "VAR" else "p"

   319

                        + node.cpath + ";"]

   320

   321

        assert(found_heartbeat)

   322

   323

        # TODO : filter only requiered external declarations

   324

        for v in varlist:

   325

            if v["C_path"].find('.') < 0:

   326

                extern_variables_declarations += [

   327

                    "extern %(type)s %(C_path)s;" % v]

   328

   329

        # TODO check if programs need to be declared separately

   330

        # "programs_declarations": "\n".join(["extern %(type)s %(C_path)s;" %

   331

        #                                     p for p in self._ProgramList]),

   332

   333

        # C code to observe/access HMI tree variables

   334

        svghmi_c_filepath = paths.AbsNeighbourFile(__file__, "svghmi.c")

   335

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   336

        svghmi_c_code = svghmi_c_file.read()

   337

        svghmi_c_file.close()

   338

        svghmi_c_code = svghmi_c_code % {

   339

            "variable_decl_array": ",\n".join(variable_decl_array),

   340

            "extern_variables_declarations": "\n".join(extern_variables_declarations),

   341

            "buffer_size": buf_index,

   342

            "item_count": item_count,

   343

            "var_access_code": targets.GetCode("var_access.c"),

   344

            "PLC_ticktime": self.GetCTR().GetTicktime(),

   345

            "hmi_hash_ints": ",".join(map(str,hmi_tree_root.hash()))

   346

            }

   347

   348

        gen_svghmi_c_path = os.path.join(buildpath, "svghmi.c")

   349

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   350

        gen_svghmi_c.write(svghmi_c_code)

   351

        gen_svghmi_c.close()

   352

   353

        # Python based WebSocket HMITree Server

   354

        svghmiserverfile = open(paths.AbsNeighbourFile(__file__, "svghmi_server.py"), 'r')

   355

        svghmiservercode = svghmiserverfile.read()

   356

        svghmiserverfile.close()

   357

   358

        runtimefile_path = os.path.join(buildpath, "runtime_00_svghmi.py")

   359

        runtimefile = open(runtimefile_path, 'w')

   360

        runtimefile.write(svghmiservercode)

   361

        runtimefile.close()

   362

   363

        # Backup HMI Tree in XML form so that it can be loaded without building

   364

        hmitree_backup_path = os.path.join(buildpath, "hmitree.xml")

   365

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   366

        hmitree_backup_file.write(etree.tostring(hmi_tree_root.etree()))

   367

        hmitree_backup_file.close()

   368

   369

        return ((["svghmi"], [(gen_svghmi_c_path, IECCFLAGS)], True), "",

   370

                ("runtime_00_svghmi.py", open(runtimefile_path, "rb")))

   371

                #         ^

   372

                # note the double zero after "runtime_", 

   373

                # to ensure placement before other CTN generated code in execution order

   374

   375

   376

class HMITreeSelector(wx.TreeCtrl):

   377

    def __init__(self, parent):

   378

        global on_hmitree_update

   379

        wx.TreeCtrl.__init__(self, parent, style=(

   380

            wx.TR_MULTIPLE |

   381

            wx.TR_HAS_BUTTONS |

   382

            wx.SUNKEN_BORDER |

   383

            wx.TR_LINES_AT_ROOT))

   384

   385

        on_hmitree_update = self.SVGHMIEditorUpdater()

   386

        self.MakeTree()

   387

   388

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   389

        for c in current_hmitree_root.children:

   390

            if hasattr(c, "children"):

   391

                display_name = ('{} (class={})'.format(c.name, c.hmiclass)) \

   392

                               if c.hmiclass is not None else c.name

   393

                tc_child = self.AppendItem(current_tc_root, display_name)

   394

                self.SetPyData(tc_child, None)

   395

   396

                self._recurseTree(c,tc_child)

   397

            else:

   398

                display_name = '{} {}'.format(c.nodetype[4:], c.name)

   399

                tc_child = self.AppendItem(current_tc_root, display_name)

   400

                self.SetPyData(tc_child, None)

   401

   402

    def MakeTree(self):

   403

        global hmi_tree_root

   404

   405

        self.Freeze()

   406

   407

        self.root = None

   408

        self.DeleteAllItems()

   409

   410

        root_display_name = _("Please build to see HMI Tree") if hmi_tree_root is None else "HMI"

   411

        self.root = self.AddRoot(root_display_name)

   412

        self.SetPyData(self.root, None)

   413

   414

        if hmi_tree_root is not None:

   415

            self._recurseTree(hmi_tree_root, self.root)

   416

            self.Expand(self.root)

   417

   418

        self.Thaw()

   419

   420

    def SVGHMIEditorUpdater(self):

   421

        selfref = weakref.ref(self)

   422

        def SVGHMIEditorUpdate():

   423

            o = selfref()

   424

            if o is not None:

   425

                wx.CallAfter(o.MakeTree)

   426

        return SVGHMIEditorUpdate

   427

   428

class HMITreeView(wx.SplitterWindow):

   429

   430

    def __init__(self, parent):

   431

        wx.SplitterWindow.__init__(self, parent,

   432

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   433

   434

        self.SelectionTree = HMITreeSelector(self)

   435

        #self.Staging = wx.Panel(self)

   436

        #self.SplitHorizontally(self.SelectionTree, self.Staging, 200)

   437

        self.Initialize(self.SelectionTree)

   438

   439

   440

class SVGHMIEditor(ConfTreeNodeEditor):

   441

    CONFNODEEDITOR_TABS = [

   442

        (_("HMI Tree"), "CreateHMITreeView")]

   443

   444

    def CreateHMITreeView(self, parent):

   445

        #self.HMITreeView = HMITreeView(self)

   446

        global hmi_tree_root

   447

   448

        if hmi_tree_root is None:

   449

            buildpath = self.Controler.GetCTRoot()._getBuildPath()

   450

            hmitree_backup_path = os.path.join(buildpath, "hmitree.xml")

   451

            if os.path.exists(hmitree_backup_path):

   452

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   453

                hmi_tree_root = HMITreeNode.from_etree(etree.parse(hmitree_backup_file).getroot())

   454

   455

        return HMITreeSelector(parent)

   456

   457

class SVGHMI(object):

   458

    XSD = """<?xml version="1.0" encoding="utf-8" ?>

   459

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

   460

      <xsd:element name="SVGHMI">

   461

        <xsd:complexType>

   462

          <xsd:attribute name="OnStart" type="xsd:string" use="optional"/>

   463

          <xsd:attribute name="OnStop" type="xsd:string" use="optional"/>

   464

          <xsd:attribute name="OnWatchdog" type="xsd:string" use="optional"/>

   465

          <xsd:attribute name="WatchdogInitial" type="xsd:integer" use="optional"/>

   466

          <xsd:attribute name="WatchdogInterval" type="xsd:integer" use="optional"/>

   467

        </xsd:complexType>

   468

      </xsd:element>

   469

    </xsd:schema>

   470

    """

   471

   472

    EditorType = SVGHMIEditor

   473

   474

    ConfNodeMethods = [

   475

        {

   476

            "bitmap":    "ImportSVG",

   477

            "name":    _("Import SVG"),

   478

            "tooltip": _("Import SVG"),

   479

            "method":   "_ImportSVG"

   480

        },

   481

        {

   482

            "bitmap":    "EditSVG",  # should be something different

   483

            "name":    _("Inkscape"),

   484

            "tooltip": _("Edit HMI"),

   485

            "method":   "_StartInkscape"

   486

        },

   487

        {

   488

            "bitmap":    "OpenPOT",  # should be something different