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

    18

import wx

    19

import wx.dataview as dv

    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

    34

HMI_TYPES_DESC = {

    35

    "HMI_NODE":{},

    36

    "HMI_STRING":{},

    37

    "HMI_INT":{},

    38

    "HMI_BOOL":{}

    39

}

    40

    41

HMI_TYPES = HMI_TYPES_DESC.keys()

    42

    43

    44

ScriptDirectory = paths.AbsDir(__file__)

    45

    46

class HMITreeNode(object):

    47

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

    48

        self.path = path

    49

        self.name = name

    50

        self.nodetype = nodetype

    51

        self.hmiclass = hmiclass

    52

    53

        if iectype is not None:

    54

            self.iectype = iectype

    55

            self.vartype = vartype

    56

            self.cpath = cpath

    57

    58

        if nodetype in ["HMI_NODE"]:

    59

            self.children = []

    60

    61

    def pprint(self, indent = 0):

    62

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

    63

        if hasattr(self, "children"):

    64

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

    65

                              for child in self.children])

    66

            res += "\n"

    67

    68

        return res

    69

    70

    def place_node(self, node):

    71

        best_child = None

    72

        known_best_match = 0

    73

        potential_siblings = {}

    74

        for child in self.children:

    75

            if child.path is not None:

    76

                in_common = 0

    77

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

    78

                    if child_path_item == node_path_item:

    79

                        in_common +=1

    80

                    else:

    81

                        break

    82

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

    83

                # must match candidate node (except for name part)

    84

                # since candidate would become child of that node

    85

                if in_common > known_best_match and \

    86

                   child.nodetype == "HMI_NODE" and \

    87

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

    88

                    known_best_match = in_common

    89

                    best_child = child

    90

                else:

    91

                    potential_siblings[child.path[

    92

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

    93

        if best_child is not None:

    94

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

    95

                return "Duplicate_HMI_NODE", best_child

    96

            return best_child.place_node(node)

    97

        else:

    98

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

    99

            if candidate_name in potential_siblings:

   100

                return "Non_Unique", potential_siblings[candidate_name]

   101

   102

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

   103

                prev = self.children[-1]

   104

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

   105

                    return "Late_HMI_NODE",prev

   106

   107

            self.children.append(node)

   108

            return None

   109

   110

    def etree(self, add_hash=False):

   111

   112

        attribs = dict(name=self.name)

   113

        if self.path is not None:

   114

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

   115

   116

        if self.hmiclass is not None:

   117

            attribs["class"] = self.hmiclass

   118

   119

        if add_hash:

   120

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

   121

   122

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

   123

   124

        if hasattr(self, "children"):

   125

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

   126

                res.append(child_etree)

   127

   128

        return res

   129

   130

    def traverse(self):

   131

        yield self

   132

        if hasattr(self, "children"):

   133

            for c in self.children:

   134

                for yoodl in c.traverse():

   135

                    yield yoodl

   136

   137

   138

    def hash(self):

   139

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

   140

        s = hashlib.new('md5')

   141

        self._hash(s)

   142

        # limit size to HMI_HASH_SIZE as in svghmi.c

   143

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

   144

   145

    def _hash(self, s):

   146

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

   147

        if hasattr(self, "children"):

   148

            for c in self.children:

   149

                c._hash(s)

   150

   151

# module scope for HMITree root

   152

# so that CTN can use HMITree deduced in Library

   153

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

   154

#       systematicaly invoked before CTN's CTNGenerate_C

   155

   156

hmi_tree_root = None

   157

   158

on_hmitree_update = None

   159

   160

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

   161

                 ("heartbeat", "HMI_INT")]

   162

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

   163

   164

class SVGHMILibrary(POULibrary):

   165

    def GetLibraryPath(self):

   166

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

   167

   168

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

   169

        global hmi_tree_root, on_hmitree_update

   170

   171

        """

   172

        PLC Instance Tree:

   173

          prog0

   174

           +->v1 HMI_INT

   175

           +->v2 HMI_INT

   176

           +->fb0 (type mhoo)

   177

           |   +->va HMI_NODE

   178

           |   +->v3 HMI_INT

   179

           |   +->v4 HMI_INT

   180

           |

   181

           +->fb1 (type mhoo)

   182

           |   +->va HMI_NODE

   183

           |   +->v3 HMI_INT

   184

           |   +->v4 HMI_INT

   185

           |

   186

           +->fb2

   187

               +->v5 HMI_IN

   188

   189

        HMI tree:

   190

          hmi0

   191

           +->v1

   192

           +->v2

   193

           +->fb0 class:va

   194

           |   +-> v3

   195

           |   +-> v4

   196

           |

   197

           +->fb1 class:va

   198

           |   +-> v3

   199

           |   +-> v4

   200

           |

   201

           +->v5

   202

   203

        """

   204

   205

        # Filter known HMI types

   206

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

   207

   208

        hmi_tree_root = None

   209

   210

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

   211

        for i,v in enumerate(hmi_types_instances):

   212

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

   213

            derived = v["derived"]

   214

            if derived == "HMI_NODE":

   215

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

   216

                hmi_types_instances.pop(i)

   217

                break

   218

   219

        assert(hmi_tree_root is not None)

   220

   221

        # deduce HMI tree from PLC HMI_* instances

   222

        for v in hmi_types_instances:

   223

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

   224

            # ignores variables starting with _TMP_

   225

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

   226

                continue

   227

            derived = v["derived"]

   228

            kwargs={}

   229

            if derived == "HMI_NODE":

   230

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

   231

                name = path[-2]

   232

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

   233

            else:

   234

                name = path[-1]

   235

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

   236

            placement_result = hmi_tree_root.place_node(new_node)

   237

            if placement_result is not None:

   238

                cause, problematic_node = placement_result

   239

                if cause == "Non_Unique":

   240

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

   241

                        ".".join(problematic_node.path),

   242

                        ".".join(new_node.path))

   243

   244

                    last_FB = None 

   245

                    for v in varlist:

   246

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

   247

                            last_FB = v 

   248

                        if v["C_path"] == problematic_node:

   249

                            break

   250

                    if last_FB is not None:

   251

                        failing_parent = last_FB["type"]

   252

                        message += "\n"

   253

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

   254

   255

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

   256

                    cause, problematic_node = placement_result

   257

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

   258

                        ".".join(problematic_node.path),

   259

                        ".".join(new_node.path))

   260

   261

                self.FatalError("SVGHMI : " + message)

   262

   263

        if on_hmitree_update is not None:

   264

            on_hmitree_update()

   265

   266

        variable_decl_array = []

   267

        extern_variables_declarations = []

   268

        buf_index = 0

   269

        item_count = 0

   270

        found_heartbeat = False

   271

   272

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   273

   274

        for node in hmi_tree_root.traverse():

   275

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   276

                hmi_tree_hearbeat_index = item_count

   277

                found_heartbeat = True

   278

                extern_variables_declarations += [

   279

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   280

                ]

   281

            if hasattr(node, "iectype"):

   282

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

   283

                variable_decl_array += [

   284

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

   285

                        "EXT": "_P_ENUM",

   286

                        "IN":  "_P_ENUM",

   287

                        "MEM": "_O_ENUM",

   288

                        "OUT": "_O_ENUM",

   289

                        "VAR": "_ENUM"

   290

                    }[node.vartype] + ", " +

   291

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

   292

                buf_index += sz

   293

                item_count += 1

   294

                if len(node.path) == 1:

   295

                    extern_variables_declarations += [

   296

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

   297

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

   298

                        + node.cpath + ";"]

   299

   300

        assert(found_heartbeat)

   301

   302

        # TODO : filter only requiered external declarations

   303

        for v in varlist:

   304

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

   305

                extern_variables_declarations += [

   306

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

   307

   308

        # TODO check if programs need to be declared separately

   309

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

   310

        #                                     p for p in self._ProgramList]),

   311

   312

        # C code to observe/access HMI tree variables

   313

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

   314

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   315

        svghmi_c_code = svghmi_c_file.read()

   316

        svghmi_c_file.close()

   317

        svghmi_c_code = svghmi_c_code % {

   318

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

   319

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

   320

            "buffer_size": buf_index,

   321

            "item_count": item_count,

   322

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

   323

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

   324

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

   325

            }

   326

   327

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

   328

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   329

        gen_svghmi_c.write(svghmi_c_code)

   330

        gen_svghmi_c.close()

   331

   332

        # Python based WebSocket HMITree Server

   333

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

   334

        svghmiservercode = svghmiserverfile.read()

   335

        svghmiserverfile.close()

   336

   338

        runtimefile = open(runtimefile_path, 'w')

   339

        runtimefile.write(svghmiservercode)

   340

        runtimefile.close()

   341

   342

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

   347

   348

   349

class HMITreeSelector(wx.TreeCtrl):

   350

    def __init__(self, parent):

   351

        global on_hmitree_update

   352

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

   353

   354

        isz = (16,16)

   355

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

   356

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

   357

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

   358

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

   359

        self.SetImageList(il)

   360

   361

        on_hmitree_update = self.SVGHMIEditorUpdater()

   362

        self.MakeTree()

   363

   364

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   365

        for c in current_hmitree_root.children:

   366

            if hasattr(c, "children"):

   367

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

   368

                               if c.hmiclass is not None else c.name

   369

                tc_child = self.AppendItem(current_tc_root, display_name)

   370

                self.SetPyData(tc_child, None)

   371

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

   372

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

   373

   374

                self._recurseTree(c,tc_child)

   375

            else:

   376

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

   377

                tc_child = self.AppendItem(current_tc_root, display_name)

   378

                self.SetPyData(tc_child, None)

   379

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

   380

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

   381

   382

    def MakeTree(self):

   383

        global hmi_tree_root

   384

   385

        self.Freeze()

   386

   387

        self.root = None

   388

        self.DeleteAllItems()

   389

   390

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

   391

        self.root = self.AddRoot(root_display_name)

   392

        self.SetPyData(self.root, None)

   393

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

   394

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

   395

   396

        if hmi_tree_root is not None:

   397

            self._recurseTree(hmi_tree_root, self.root)

   398

   399

        self.Thaw()

   400

   401

    def SVGHMIEditorUpdater(self):

   402

        selfref = weakref.ref(self)

   403

        def SVGHMIEditorUpdate():

   404

            o = selfref()

   405

            if o is not None:

   406

                wx.CallAfter(o.MakeTree)

   407

        return SVGHMIEditorUpdate

   408

   409

class HMITreeView(wx.SplitterWindow):

   410

   411

    def __init__(self, parent):

   412

        wx.SplitterWindow.__init__(self, parent,

   413

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   414

   415

        self.SelectionTree = HMITreeSelector(self)

   416

        #self.Staging = wx.Panel(self)

   417

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

   418

        self.Initialize(self.SelectionTree)

   419

   420

   421

class SVGHMIEditor(ConfTreeNodeEditor):

   422

    CONFNODEEDITOR_TABS = [

   423

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

   424

   425

    def CreateHMITreeView(self, parent):

   426

        #self.HMITreeView = HMITreeView(self)

   427

        return HMITreeSelector(parent)

   428

   429

   430

class SVGHMI(object):

   431

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

   432

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

   433

      <xsd:element name="SVGHMI">

   434

        <xsd:complexType>

   435

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

   436

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

   437

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

   438

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

   439

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

   440

        </xsd:complexType>

   441

      </xsd:element>

   442

    </xsd:schema>

   443

    """

   444

   445

    EditorType = SVGHMIEditor

   446

   447

    ConfNodeMethods = [

   448

        {

   449

            "bitmap":    "ImportSVG",

   450

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

   451

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

   452

            "method":   "_ImportSVG"

   453

        },

   454

        {

   455

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

   456

            "name":    _("Inkscape"),

   457

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

   458

            "method":   "_StartInkscape"

   459

        },

   460

   461

        # TODO : Launch POEdit button

   462

        #        PO -> SVG layers button

   463

        #        SVG layers -> PO

   464

   465

        # TODO : HMITree button

   466

        #        - can drag'n'drop variabes to Inkscape

   467

   468

    ]

   469

   470

    def _getSVGpath(self, project_path=None):

   471

        if project_path is None:

   472

            project_path = self.CTNPath()

   473

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

   474

   475

   476

    def OnCTNSave(self, from_project_path=None):

   477

        if from_project_path is not None:

   478

            shutil.copyfile(self._getSVGpath(from_project_path),

   479

                            self._getSVGpath())

   480

        return True

   481

   482

    def GetSVGGeometry(self):

   483

        # invoke inskscape -S, csv-parse output, produce elements

   484

        InkscapeGeomColumns = ["Id", "x", "y", "w", "h"]

   485

   486

        inkpath = get_inkscape_path()

   487

        svgpath = self._getSVGpath()

   488

        _status, result, _err_result = ProcessLogger(self.GetCTRoot().logger,

   489

                                                     inkpath + " -S " + svgpath,