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

    25

import util.paths as paths

    26

from POULibrary import POULibrary

    27

from docutil import open_svg, get_inkscape_path

    28

    29

from util.ProcessLogger import ProcessLogger

    30

from runtime.typemapping import DebugTypesSize

    31

import targets

    32

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    33

from XSLTransform import XSLTransform

    34

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

    35

    36

HMI_TYPES_DESC = {

    37

    "HMI_NODE":{},

    38

    "HMI_STRING":{},

    39

    "HMI_INT":{},

    40

    "HMI_BOOL":{},

    41

    "HMI_REAL":{}

    42

}

    43

    44

HMI_TYPES = HMI_TYPES_DESC.keys()

    45

    46

    47

ScriptDirectory = paths.AbsDir(__file__)

    48

    49

class HMITreeNode(object):

    50

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

    51

        self.path = path

    52

        self.name = name

    53

        self.nodetype = nodetype

    54

        self.hmiclass = hmiclass

    55

    56

        if iectype is not None:

    57

            self.iectype = iectype

    58

            self.vartype = vartype

    59

            self.cpath = cpath

    60

    61

        if nodetype in ["HMI_NODE"]:

    62

            self.children = []

    63

    64

    def pprint(self, indent = 0):

    65

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

    66

        if hasattr(self, "children"):

    67

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

    68

                              for child in self.children])

    69

            res += "\n"

    70

    71

        return res

    72

    73

    def place_node(self, node):

    74

        best_child = None

    75

        known_best_match = 0

    76

        potential_siblings = {}

    77

        for child in self.children:

    78

            if child.path is not None:

    79

                in_common = 0

    80

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

    81

                    if child_path_item == node_path_item:

    82

                        in_common +=1

    83

                    else:

    84

                        break

    85

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

    86

                # must match candidate node (except for name part)

    87

                # since candidate would become child of that node

    88

                if in_common > known_best_match and \

    89

                   child.nodetype == "HMI_NODE" and \

    90

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

    91

                    known_best_match = in_common

    92

                    best_child = child

    93

                else:

    94

                    potential_siblings[child.path[

    95

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

    96

        if best_child is not None:

    97

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

    98

                return "Duplicate_HMI_NODE", best_child

    99

            return best_child.place_node(node)

   100

        else:

   101

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

   102

            if candidate_name in potential_siblings:

   103

                return "Non_Unique", potential_siblings[candidate_name]

   104

   105

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

   106

                prev = self.children[-1]

   107

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

   108

                    return "Late_HMI_NODE",prev

   109

   110

            self.children.append(node)

   111

            return None

   112

   113

    def etree(self, add_hash=False):

   114

   115

        attribs = dict(name=self.name)

   116

        if self.path is not None:

   117

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

   118

   119

        if self.hmiclass is not None:

   120

            attribs["class"] = self.hmiclass

   121

   122

        if add_hash:

   123

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

   124

   125

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

   126

   127

        if hasattr(self, "children"):

   128

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

   129

                res.append(child_etree)

   130

   131

        return res

   132

   133

    @classmethod

   134

    def from_etree(cls, enode):

   135

        """

   136

        alternative constructor, restoring HMI Tree from XML backup

   137

        note: all C-related information is gone, 

   138

              this restore is only for tree display and widget picking

   139

        """

   140

        nodetype = enode.tag

   141

        attributes = enode.attrib

   142

        name = attributes["name"]

   143

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

   144

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

   145

        # hash is computed on demand

   146

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

   147

        for child in enode.iterchildren():

   148

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

   149

        return node

   150

   151

    def traverse(self):

   152

        yield self

   153

        if hasattr(self, "children"):

   154

            for c in self.children:

   155

                for yoodl in c.traverse():

   156

                    yield yoodl

   157

   158

   159

    def hash(self):

   160

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

   161

        s = hashlib.new('md5')

   162

        self._hash(s)

   163

        # limit size to HMI_HASH_SIZE as in svghmi.c

   164

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

   165

   166

    def _hash(self, s):

   167

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

   168

        if hasattr(self, "children"):

   169

            for c in self.children:

   170

                c._hash(s)

   171

   172

# module scope for HMITree root

   173

# so that CTN can use HMITree deduced in Library

   174

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

   175

#       systematicaly invoked before CTN's CTNGenerate_C

   176

   177

hmi_tree_root = None

   178

   179

on_hmitree_update = None

   180

   181

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

   182

                 ("heartbeat", "HMI_INT")]

   183

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

   184

   185

class SVGHMILibrary(POULibrary):

   186

    def GetLibraryPath(self):

   187

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

   188

   189

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

   190

        global hmi_tree_root, on_hmitree_update

   191

   192

        """

   193

        PLC Instance Tree:

   194

          prog0

   195

           +->v1 HMI_INT

   196

           +->v2 HMI_INT

   197

           +->fb0 (type mhoo)

   198

           |   +->va HMI_NODE

   199

           |   +->v3 HMI_INT

   200

           |   +->v4 HMI_INT

   201

           |

   202

           +->fb1 (type mhoo)

   203

           |   +->va HMI_NODE

   204

           |   +->v3 HMI_INT

   205

           |   +->v4 HMI_INT

   206

           |

   207

           +->fb2

   208

               +->v5 HMI_IN

   209

   210

        HMI tree:

   211

          hmi0

   212

           +->v1

   213

           +->v2

   214

           +->fb0 class:va

   215

           |   +-> v3

   216

           |   +-> v4

   217

           |

   218

           +->fb1 class:va

   219

           |   +-> v3

   220

           |   +-> v4

   221

           |

   222

           +->v5

   223

   224

        """

   225

   226

        # Filter known HMI types

   227

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

   228

   229

        hmi_tree_root = None

   230

   231

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

   232

        for i,v in enumerate(hmi_types_instances):

   233

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

   234

            derived = v["derived"]

   235

            if derived == "HMI_NODE":

   236

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

   237

                hmi_types_instances.pop(i)

   238

                break

   239

   240

        if hmi_tree_root is None:

   241

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

   242

   243

        # deduce HMI tree from PLC HMI_* instances

   244

        for v in hmi_types_instances:

   245

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

   246

            # ignores variables starting with _TMP_

   247

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

   248

                continue

   249

            derived = v["derived"]

   250

            kwargs={}

   251

            if derived == "HMI_NODE":

   252

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

   253

                name = path[-2]

   254

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

   255

            else:

   256

                name = path[-1]

   257

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

   258

            placement_result = hmi_tree_root.place_node(new_node)

   259

            if placement_result is not None:

   260

                cause, problematic_node = placement_result

   261

                if cause == "Non_Unique":

   262

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

   263

                        ".".join(problematic_node.path),

   264

                        ".".join(new_node.path))

   265

   266

                    last_FB = None 

   267

                    for v in varlist:

   268

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

   269

                            last_FB = v 

   270

                        if v["C_path"] == problematic_node:

   271

                            break

   272

                    if last_FB is not None:

   273

                        failing_parent = last_FB["type"]

   274

                        message += "\n"

   275

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

   276

   277

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

   278

                    cause, problematic_node = placement_result

   279

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

   280

                        ".".join(problematic_node.path),

   281

                        ".".join(new_node.path))

   282

   283

                self.FatalError("SVGHMI : " + message)

   284

   285

        if on_hmitree_update is not None:

   286

            on_hmitree_update()

   287

   288

        variable_decl_array = []

   289

        extern_variables_declarations = []

   290

        buf_index = 0

   291

        item_count = 0

   292

        found_heartbeat = False

   293

   294

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   295

   296

        for node in hmi_tree_root.traverse():

   297

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   298

                hmi_tree_hearbeat_index = item_count

   299

                found_heartbeat = True

   300

                extern_variables_declarations += [

   301

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   302

                ]

   303

            if hasattr(node, "iectype"):

   304

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

   305

                variable_decl_array += [

   306

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

   307

                        "EXT": "_P_ENUM",

   308

                        "IN":  "_P_ENUM",

   309

                        "MEM": "_O_ENUM",

   310

                        "OUT": "_O_ENUM",

   311

                        "VAR": "_ENUM"

   312

                    }[node.vartype] + ", " +

   313

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

   314

                buf_index += sz

   315

                item_count += 1

   316

                if len(node.path) == 1:

   317

                    extern_variables_declarations += [

   318

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

   319

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

   320

                        + node.cpath + ";"]

   321

   322

        assert(found_heartbeat)

   323

   324

        # TODO : filter only requiered external declarations

   325

        for v in varlist:

   326

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

   327

                extern_variables_declarations += [

   328

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

   329

   330

        # TODO check if programs need to be declared separately

   331

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

   332

        #                                     p for p in self._ProgramList]),

   333

   334

        # C code to observe/access HMI tree variables

   335

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

   336

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   337

        svghmi_c_code = svghmi_c_file.read()

   338

        svghmi_c_file.close()

   339

        svghmi_c_code = svghmi_c_code % {

   340

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

   341

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

   342

            "buffer_size": buf_index,

   343

            "item_count": item_count,

   344

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

   345

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

   346

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

   347

            }

   348

   349

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

   350

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   351

        gen_svghmi_c.write(svghmi_c_code)

   352

        gen_svghmi_c.close()

   353

   354

        # Python based WebSocket HMITree Server

   355

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

   356

        svghmiservercode = svghmiserverfile.read()

   357

        svghmiserverfile.close()

   358

   359

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

   360

        runtimefile = open(runtimefile_path, 'w')

   361

        runtimefile.write(svghmiservercode)

   362

        runtimefile.close()

   363

   364

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

   365

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

   366

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   367

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

   368

        hmitree_backup_file.close()

   369

   370

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

   371

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

   372

                #         ^

   373

                # note the double zero after "runtime_", 

   374

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

   375

   376

   384

class HMITreeSelector(wx.TreeCtrl):

   385

    def __init__(self, parent):

   386

        global on_hmitree_update

   387

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

   388

            wx.TR_MULTIPLE |

   389

            wx.TR_HAS_BUTTONS |

   390

            wx.SUNKEN_BORDER |

   391

            wx.TR_LINES_AT_ROOT))

   392

   394

        self.MakeTree()

   395

   396

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   397

        for c in current_hmitree_root.children:

   398

            if hasattr(c, "children"):

   399

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

   400

                               if c.hmiclass is not None else c.name

   401

                tc_child = self.AppendItem(current_tc_root, display_name)

   403

   404

                self._recurseTree(c,tc_child)

   405

            else:

   406

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

   407

                tc_child = self.AppendItem(current_tc_root, display_name)

   409

   410

    def MakeTree(self):

   411

        global hmi_tree_root

   412

   413

        self.Freeze()

   414

   415

        self.root = None

   416

        self.DeleteAllItems()

   417

   420

        self.root = self.AddRoot(root_display_name)

   421

        self.SetPyData(self.root, None)

   422

   423

        if hmi_tree_root is not None:

   424

            self._recurseTree(hmi_tree_root, self.root)

   425

            self.Expand(self.root)

   426

   427

        self.Thaw()

   428