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

import wx.dataview as dv

    21

    22

from lxml import etree

    23

from lxml.etree import XSLTApplyError

    24

    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

    def traverse(self):

   134

        yield self

   135

        if hasattr(self, "children"):

   136

            for c in self.children:

   137

                for yoodl in c.traverse():

   138

                    yield yoodl

   139

   140

   141

    def hash(self):

   142

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

   143

        s = hashlib.new('md5')

   144

        self._hash(s)

   145

        # limit size to HMI_HASH_SIZE as in svghmi.c

   146

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

   147

   148

    def _hash(self, s):

   149

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

   150

        if hasattr(self, "children"):

   151

            for c in self.children:

   152

                c._hash(s)

   153

   154

# module scope for HMITree root

   155

# so that CTN can use HMITree deduced in Library

   156

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

   157

#       systematicaly invoked before CTN's CTNGenerate_C

   158

   159

hmi_tree_root = None

   160

   161

on_hmitree_update = None

   162

   163

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

   164

                 ("heartbeat", "HMI_INT")]

   165

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

   166

   167

class SVGHMILibrary(POULibrary):

   168

    def GetLibraryPath(self):

   169

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

   170

   171

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

   172

        global hmi_tree_root, on_hmitree_update

   173

   174

        """

   175

        PLC Instance Tree:

   176

          prog0

   177

           +->v1 HMI_INT

   178

           +->v2 HMI_INT

   179

           +->fb0 (type mhoo)

   180

           |   +->va HMI_NODE

   181

           |   +->v3 HMI_INT

   182

           |   +->v4 HMI_INT

   183

           |

   184

           +->fb1 (type mhoo)

   185

           |   +->va HMI_NODE

   186

           |   +->v3 HMI_INT

   187

           |   +->v4 HMI_INT

   188

           |

   189

           +->fb2

   190

               +->v5 HMI_IN

   191

   192

        HMI tree:

   193

          hmi0

   194

           +->v1

   195

           +->v2

   196

           +->fb0 class:va

   197

           |   +-> v3

   198

           |   +-> v4

   199

           |

   200

           +->fb1 class:va

   201

           |   +-> v3

   202

           |   +-> v4

   203

           |

   204

           +->v5

   205

   206

        """

   207

   208

        # Filter known HMI types

   209

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

   210

   211

        hmi_tree_root = None

   212

   213

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

   214

        for i,v in enumerate(hmi_types_instances):

   215

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

   216

            derived = v["derived"]

   217

            if derived == "HMI_NODE":

   218

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

   219

                hmi_types_instances.pop(i)

   220

                break

   221

   222

        if hmi_tree_root is None:

   223

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

   224

   225

        # deduce HMI tree from PLC HMI_* instances

   226

        for v in hmi_types_instances:

   227

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

   228

            # ignores variables starting with _TMP_

   229

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

   230

                continue

   231

            derived = v["derived"]

   232

            kwargs={}

   233

            if derived == "HMI_NODE":

   234

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

   235

                name = path[-2]

   236

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

   237

            else:

   238

                name = path[-1]

   239

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

   240

            placement_result = hmi_tree_root.place_node(new_node)

   241

            if placement_result is not None:

   242

                cause, problematic_node = placement_result

   243

                if cause == "Non_Unique":

   244

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

   245

                        ".".join(problematic_node.path),

   246

                        ".".join(new_node.path))

   247

   248

                    last_FB = None 

   249

                    for v in varlist:

   250

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

   251

                            last_FB = v 

   252

                        if v["C_path"] == problematic_node:

   253

                            break

   254

                    if last_FB is not None:

   255

                        failing_parent = last_FB["type"]

   256

                        message += "\n"

   257

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

   258

   259

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

   260

                    cause, problematic_node = placement_result

   261

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

   262

                        ".".join(problematic_node.path),

   263

                        ".".join(new_node.path))

   264

   265

                self.FatalError("SVGHMI : " + message)

   266

   267

        if on_hmitree_update is not None:

   268

            on_hmitree_update()

   269

   270

        variable_decl_array = []

   271

        extern_variables_declarations = []

   272

        buf_index = 0

   273

        item_count = 0

   274

        found_heartbeat = False

   275

   276

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   277

   278

        for node in hmi_tree_root.traverse():

   279

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   280

                hmi_tree_hearbeat_index = item_count

   281

                found_heartbeat = True

   282

                extern_variables_declarations += [

   283

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   284

                ]

   285

            if hasattr(node, "iectype"):

   286

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

   287

                variable_decl_array += [

   288

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

   289

                        "EXT": "_P_ENUM",

   290

                        "IN":  "_P_ENUM",

   291

                        "MEM": "_O_ENUM",

   292

                        "OUT": "_O_ENUM",

   293

                        "VAR": "_ENUM"

   294

                    }[node.vartype] + ", " +

   295

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

   296

                buf_index += sz

   297

                item_count += 1

   298

                if len(node.path) == 1:

   299

                    extern_variables_declarations += [

   300

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

   301

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

   302

                        + node.cpath + ";"]

   303

   304

        assert(found_heartbeat)

   305

   306

        # TODO : filter only requiered external declarations

   307

        for v in varlist:

   308

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

   309

                extern_variables_declarations += [

   310

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

   311

   312

        # TODO check if programs need to be declared separately

   313

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

   314

        #                                     p for p in self._ProgramList]),

   315

   316

        # C code to observe/access HMI tree variables

   317

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

   318

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   319

        svghmi_c_code = svghmi_c_file.read()

   320

        svghmi_c_file.close()

   321

        svghmi_c_code = svghmi_c_code % {

   322

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

   323

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

   324

            "buffer_size": buf_index,

   325

            "item_count": item_count,

   326

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

   327

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

   328

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

   329

            }

   330

   331

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

   332

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   333

        gen_svghmi_c.write(svghmi_c_code)

   334

        gen_svghmi_c.close()

   335

   336

        # Python based WebSocket HMITree Server

   337

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

   338

        svghmiservercode = svghmiserverfile.read()

   339

        svghmiserverfile.close()

   340

   341

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

   342

        runtimefile = open(runtimefile_path, 'w')

   343

        runtimefile.write(svghmiservercode)

   344

        runtimefile.close()

   345

   346

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

   347

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

   348

                #         ^

   349

                # note the double zero after "runtime_", 

   350

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

   351

   352

   353

class HMITreeSelector(wx.TreeCtrl):

   354

    def __init__(self, parent):

   355

        global on_hmitree_update

   356

        wx.TreeCtrl.__init__(self,parent,style=wx.TR_MULTIPLE)# | wx.TR_HIDE_ROOT)

   357

   358

        isz = (16,16)

   359

        self.il = il = wx.ImageList(*isz)

   360

        self.fldridx     = il.AddIcon(wx.ArtProvider.GetIcon(wx.ART_FOLDER,      wx.ART_OTHER, isz))

   361

        self.fldropenidx = il.AddIcon(wx.ArtProvider.GetIcon(wx.ART_FOLDER_OPEN, wx.ART_OTHER, isz))

   362

        self.fileidx     = il.AddIcon(wx.ArtProvider.GetIcon(wx.ART_NORMAL_FILE, wx.ART_OTHER, isz))

   363

        self.SetImageList(il)

   364

   365

        on_hmitree_update = self.SVGHMIEditorUpdater()

   366

        self.MakeTree()

   367

   368

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   369

        for c in current_hmitree_root.children:

   370

            if hasattr(c, "children"):

   371

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

   372

                               if c.hmiclass is not None else c.name

   373

                tc_child = self.AppendItem(current_tc_root, display_name)

   374

                self.SetPyData(tc_child, None)

   375

                self.SetItemImage(tc_child, self.fldridx, wx.TreeItemIcon_Normal)

   376

                self.SetItemImage(tc_child, self.fldropenidx, wx.TreeItemIcon_Expanded)

   377

   378

                self._recurseTree(c,tc_child)

   379

            else:

   380

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

   381

                tc_child = self.AppendItem(current_tc_root, display_name)

   382

                self.SetPyData(tc_child, None)

   383

                self.SetItemImage(tc_child, self.fileidx, wx.TreeItemIcon_Normal)

   384

                self.SetItemImage(tc_child, self.fileidx, wx.TreeItemIcon_Expanded)

   385

   386

    def MakeTree(self):

   387

        global hmi_tree_root

   388

   389

        self.Freeze()

   390

   391

        self.root = None

   392

        self.DeleteAllItems()

   393

   394

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

   395

        self.root = self.AddRoot(root_display_name)

   396

        self.SetPyData(self.root, None)

   397

        self.SetItemImage(self.root, self.fldridx, wx.TreeItemIcon_Normal)

   398

        self.SetItemImage(self.root, self.fldropenidx, wx.TreeItemIcon_Expanded)

   399

   400

        if hmi_tree_root is not None:

   401

            self._recurseTree(hmi_tree_root, self.root)

   402

   403

        self.Thaw()

   404

   405

    def SVGHMIEditorUpdater(self):

   406

        selfref = weakref.ref(self)

   407

        def SVGHMIEditorUpdate():

   408

            o = selfref()

   409

            if o is not None:

   410

                wx.CallAfter(o.MakeTree)

   411

        return SVGHMIEditorUpdate

   412

   413

class HMITreeView(wx.SplitterWindow):

   414

   415

    def __init__(self, parent):

   416

        wx.SplitterWindow.__init__(self, parent,

   417

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   418

   419

        self.SelectionTree = HMITreeSelector(self)

   420

        #self.Staging = wx.Panel(self)

   421

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

   422

        self.Initialize(self.SelectionTree)

   423

   424

   425

class SVGHMIEditor(ConfTreeNodeEditor):

   426

    CONFNODEEDITOR_TABS = [

   427

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

   428

   429

    def CreateHMITreeView(self, parent):

   430

        #self.HMITreeView = HMITreeView(self)

   431

        return HMITreeSelector(parent)

   432

   433

class SVGHMI(object):

   434

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

   435

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

   436

      <xsd:element name="SVGHMI">

   437

        <xsd:complexType>

   438

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

   439

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

   440

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

   441

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

   442

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

   443

        </xsd:complexType>

   444

      </xsd:element>

   445

    </xsd:schema>

   446

    """

   447

   448

    EditorType = SVGHMIEditor

   449

   450

    ConfNodeMethods = [

   451

        {

   452

            "bitmap":    "ImportSVG",

   453

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

   454

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

   455

            "method":   "_ImportSVG"

   456

        },

   457

        {

   458

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

   459

            "name":    _("Inkscape"),

   460

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

   461

            "method":   "_StartInkscape"

   462

        },

   463

        {

   464

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

   465

            "name":    _("New lang"),

   466

            "tooltip": _("Open non translated message catalog (POT) to start new language"),

   467

            "method":   "_OpenPOT"

   468

        },

   469

   470

        {

   471

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

   472

            "name":    _("Edit lang"),

   473

            "tooltip": _("Edit existing message catalog (PO) for specific language"),

   474

            "method":   "_EditPO"

   475

        },

   476

   477

        # TODO : HMITree button

   478

        #        - can drag'n'drop variabes to Inkscape

   479

    ]

   480

   481

    def _getSVGpath(self, project_path=None):

   482

        if project_path is None:

   483

            project_path = self.CTNPath()

   484

        return os.path.join(project_path, "svghmi.svg")

   485

   486

    def _getPOTpath(self, project_path=None):

   487

        if project_path is None:

   488

            project_path = self.CTNPath()

   489

        return os.path.join(project_path, "messages.pot")