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

   337

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

   338

        runtimefile = open(runtimefile_path, 'w')

   339

        runtimefile.write(svghmiservercode)

   340

        runtimefile.close()

   341

   342

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

   343

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

   344

   345

   346

class HMITreeSelector(wx.TreeCtrl):

   347

    def __init__(self, parent):

   348

        global on_hmitree_update

   349

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

   350

   351

        isz = (16,16)

   352

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

   353

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

   354

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

   355

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

   356

        self.SetImageList(il)

   357

   358

        on_hmitree_update = self.SVGHMIEditorUpdater()

   359

        self.MakeTree()

   360

   361

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   362

        for c in current_hmitree_root.children:

   363

            if hasattr(c, "children"):

   364

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

   365

                               if c.hmiclass is not None else c.name

   366

                tc_child = self.AppendItem(current_tc_root, display_name)

   367

                self.SetPyData(tc_child, None)

   368

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

   369

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

   370

   371

                self._recurseTree(c,tc_child)

   372

            else:

   373

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

   374

                tc_child = self.AppendItem(current_tc_root, display_name)

   375

                self.SetPyData(tc_child, None)

   376

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

   377

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

   378

   379

    def MakeTree(self):

   380

        global hmi_tree_root

   381

   382

        self.Freeze()

   383

   384

        self.root = None

   385

        self.DeleteAllItems()

   386

   387

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

   388

        self.root = self.AddRoot(root_display_name)

   389

        self.SetPyData(self.root, None)

   390

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

   391

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

   392

   393

        if hmi_tree_root is not None:

   394

            self._recurseTree(hmi_tree_root, self.root)

   395

   396

        self.Thaw()

   397

   398

    def SVGHMIEditorUpdater(self):

   399

        selfref = weakref.ref(self)

   400

        def SVGHMIEditorUpdate():

   401

            o = selfref()

   402

            if o is not None:

   403

                wx.CallAfter(o.MakeTree)

   404

        return SVGHMIEditorUpdate

   405

   406

class HMITreeView(wx.SplitterWindow):

   407

   408

    def __init__(self, parent):

   409

        wx.SplitterWindow.__init__(self, parent,

   410

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   411

   412

        self.SelectionTree = HMITreeSelector(self)

   413

        #self.Staging = wx.Panel(self)

   414

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

   415

        self.Initialize(self.SelectionTree)

   416

   417

   418

class SVGHMIEditor(ConfTreeNodeEditor):

   419

    CONFNODEEDITOR_TABS = [

   420

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

   421

   422

    def CreateHMITreeView(self, parent):

   423

        #self.HMITreeView = HMITreeView(self)

   424

        return HMITreeSelector(parent)

   425

   426

   427

class SVGHMI(object):

   428

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

   429

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

   430

      <xsd:element name="SVGHMI">

   431

        <xsd:complexType>

   432

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

   433

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

   434

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

   435

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

   436

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

   437

        </xsd:complexType>

   438

      </xsd:element>

   439

    </xsd:schema>

   440

    """

   441

   442

    EditorType = SVGHMIEditor

   443

   444

    ConfNodeMethods = [

   445

        {

   446

            "bitmap":    "ImportSVG",

   447

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

   448

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

   449

            "method":   "_ImportSVG"

   450

        },

   451

        {

   452

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

   453

            "name":    _("Inkscape"),

   454

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

   455

            "method":   "_StartInkscape"

   456

        },

   457

   458

        # TODO : Launch POEdit button

   459

        #        PO -> SVG layers button

   460

        #        SVG layers -> PO

   461

   462

        # TODO : HMITree button

   463

        #        - can drag'n'drop variabes to Inkscape

   464

   465

    ]

   466

   467

    def _getSVGpath(self, project_path=None):

   468

        if project_path is None:

   469

            project_path = self.CTNPath()

   470

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

   471

   472

   473

    def OnCTNSave(self, from_project_path=None):

   474

        if from_project_path is not None:

   475

            shutil.copyfile(self._getSVGpath(from_project_path),

   476

                            self._getSVGpath())

   477

        return True

   478

   479

    def GetSVGGeometry(self):

   480

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

   481

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

   482

   483

        inkpath = get_inkscape_path()

   484

        svgpath = self._getSVGpath()

   485

        _status, result, _err_result = ProcessLogger(None,

   486

                                                     inkpath + " -S " + svgpath,

   487

                                                     no_stdout=True,

   488

                                                     no_stderr=True).spin()

   489

        res = []