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

    "HMI_REAL":{}

    40

}

    41

    42

HMI_TYPES = HMI_TYPES_DESC.keys()

    43

    44

    45

ScriptDirectory = paths.AbsDir(__file__)

    46

    47

class HMITreeNode(object):

    48

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

    49

        self.path = path

    50

        self.name = name

    51

        self.nodetype = nodetype

    52

        self.hmiclass = hmiclass

    53

    54

        if iectype is not None:

    55

            self.iectype = iectype

    56

            self.vartype = vartype

    57

            self.cpath = cpath

    58

    59

        if nodetype in ["HMI_NODE"]:

    60

            self.children = []

    61

    62

    def pprint(self, indent = 0):

    63

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

    64

        if hasattr(self, "children"):

    65

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

    66

                              for child in self.children])

    67

            res += "\n"

    68

    69

        return res

    70

    71

    def place_node(self, node):

    72

        best_child = None

    73

        known_best_match = 0

    74

        potential_siblings = {}

    75

        for child in self.children:

    76

            if child.path is not None:

    77

                in_common = 0

    78

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

    79

                    if child_path_item == node_path_item:

    80

                        in_common +=1

    81

                    else:

    82

                        break

    83

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

    84

                # must match candidate node (except for name part)

    85

                # since candidate would become child of that node

    86

                if in_common > known_best_match and \

    87

                   child.nodetype == "HMI_NODE" and \

    88

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

    89

                    known_best_match = in_common

    90

                    best_child = child

    91

                else:

    92

                    potential_siblings[child.path[

    93

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

    94

        if best_child is not None:

    95

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

    96

                return "Duplicate_HMI_NODE", best_child

    97

            return best_child.place_node(node)

    98

        else:

    99

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

   100

            if candidate_name in potential_siblings:

   101

                return "Non_Unique", potential_siblings[candidate_name]

   102

   103

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

   104

                prev = self.children[-1]

   105

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

   106

                    return "Late_HMI_NODE",prev

   107

   108

            self.children.append(node)

   109

            return None

   110

   111

    def etree(self, add_hash=False):

   112

   113

        attribs = dict(name=self.name)

   114

        if self.path is not None:

   115

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

   116

   117

        if self.hmiclass is not None:

   118

            attribs["class"] = self.hmiclass

   119

   120

        if add_hash:

   121

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

   122

   123

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

   124

   125

        if hasattr(self, "children"):

   126

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

   127

                res.append(child_etree)

   128

   129

        return res

   130

   131

    def traverse(self):

   132

        yield self

   133

        if hasattr(self, "children"):

   134

            for c in self.children:

   135

                for yoodl in c.traverse():

   136

                    yield yoodl

   137

   138

   139

    def hash(self):

   140

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

   141

        s = hashlib.new('md5')

   142

        self._hash(s)

   143

        # limit size to HMI_HASH_SIZE as in svghmi.c

   144

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

   145

   146

    def _hash(self, s):

   147

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

   148

        if hasattr(self, "children"):

   149

            for c in self.children:

   150

                c._hash(s)

   151

   152

# module scope for HMITree root

   153

# so that CTN can use HMITree deduced in Library

   154

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

   155

#       systematicaly invoked before CTN's CTNGenerate_C

   156

   157

hmi_tree_root = None

   158

   159

on_hmitree_update = None

   160

   161

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

   162

                 ("heartbeat", "HMI_INT")]

   163

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

   164

   165

class SVGHMILibrary(POULibrary):

   166

    def GetLibraryPath(self):

   167

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

   168

   169

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

   170

        global hmi_tree_root, on_hmitree_update

   171

   172

        """

   173

        PLC Instance Tree:

   174

          prog0

   175

           +->v1 HMI_INT

   176

           +->v2 HMI_INT

   177

           +->fb0 (type mhoo)

   178

           |   +->va HMI_NODE

   179

           |   +->v3 HMI_INT

   180

           |   +->v4 HMI_INT

   181

           |

   182

           +->fb1 (type mhoo)

   183

           |   +->va HMI_NODE

   184

           |   +->v3 HMI_INT

   185

           |   +->v4 HMI_INT

   186

           |

   187

           +->fb2

   188

               +->v5 HMI_IN

   189

   190

        HMI tree:

   191

          hmi0

   192

           +->v1

   193

           +->v2

   194

           +->fb0 class:va

   195

           |   +-> v3

   196

           |   +-> v4

   197

           |

   198

           +->fb1 class:va

   199

           |   +-> v3

   200

           |   +-> v4

   201

           |

   202

           +->v5

   203

   204

        """

   205

   206

        # Filter known HMI types

   207

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

   208

   209

        hmi_tree_root = None

   210

   211

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

   212

        for i,v in enumerate(hmi_types_instances):

   213

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

   214

            derived = v["derived"]

   215

            if derived == "HMI_NODE":

   216

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

   217

                hmi_types_instances.pop(i)

   218

                break

   219

   220

        if hmi_tree_root is None:

   221

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

   222

   223

        # deduce HMI tree from PLC HMI_* instances

   224

        for v in hmi_types_instances:

   225

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

   226

            # ignores variables starting with _TMP_

   227

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

   228

                continue

   229

            derived = v["derived"]

   230

            kwargs={}

   231

            if derived == "HMI_NODE":

   232

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

   233

                name = path[-2]

   234

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

   235

            else:

   236

                name = path[-1]

   237

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

   238

            placement_result = hmi_tree_root.place_node(new_node)

   239

            if placement_result is not None:

   240

                cause, problematic_node = placement_result

   241

                if cause == "Non_Unique":

   242

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

   243

                        ".".join(problematic_node.path),

   244

                        ".".join(new_node.path))

   245

   246

                    last_FB = None 

   247

                    for v in varlist:

   248

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

   249

                            last_FB = v 

   250

                        if v["C_path"] == problematic_node:

   251

                            break

   252

                    if last_FB is not None:

   253

                        failing_parent = last_FB["type"]

   254

                        message += "\n"

   255

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

   256

   257

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

   258

                    cause, problematic_node = placement_result

   259

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

   260

                        ".".join(problematic_node.path),

   261

                        ".".join(new_node.path))

   262

   263

                self.FatalError("SVGHMI : " + message)

   264

   265

        if on_hmitree_update is not None:

   266

            on_hmitree_update()

   267

   268

        variable_decl_array = []

   269

        extern_variables_declarations = []

   270

        buf_index = 0

   271

        item_count = 0

   272

        found_heartbeat = False

   273

   274

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   275

   276

        for node in hmi_tree_root.traverse():

   277

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   278

                hmi_tree_hearbeat_index = item_count

   279

                found_heartbeat = True

   280

                extern_variables_declarations += [

   281

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   282

                ]

   283

            if hasattr(node, "iectype"):

   284

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

   285

                variable_decl_array += [

   286

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

   287

                        "EXT": "_P_ENUM",

   288

                        "IN":  "_P_ENUM",

   289

                        "MEM": "_O_ENUM",

   290

                        "OUT": "_O_ENUM",

   291

                        "VAR": "_ENUM"

   292

                    }[node.vartype] + ", " +

   293

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

   294

                buf_index += sz

   295

                item_count += 1

   296

                if len(node.path) == 1:

   297

                    extern_variables_declarations += [

   298

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

   299

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

   300

                        + node.cpath + ";"]

   301

   302

        assert(found_heartbeat)

   303

   304

        # TODO : filter only requiered external declarations

   305

        for v in varlist:

   306

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

   307

                extern_variables_declarations += [

   308

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

   309

   310

        # TODO check if programs need to be declared separately

   311

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

   312

        #                                     p for p in self._ProgramList]),

   313

   314

        # C code to observe/access HMI tree variables

   315

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

   316

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   317

        svghmi_c_code = svghmi_c_file.read()

   318

        svghmi_c_file.close()

   319

        svghmi_c_code = svghmi_c_code % {

   320

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

   321

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

   322

            "buffer_size": buf_index,

   323

            "item_count": item_count,

   324

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

   325

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

   326

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

   327

            }

   328

   329

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

   330

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   331

        gen_svghmi_c.write(svghmi_c_code)

   332

        gen_svghmi_c.close()

   333

   334

        # Python based WebSocket HMITree Server

   335

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

   336

        svghmiservercode = svghmiserverfile.read()

   337

        svghmiserverfile.close()

   338

   339

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

   340

        runtimefile = open(runtimefile_path, 'w')

   341

        runtimefile.write(svghmiservercode)

   342

        runtimefile.close()

   343

   344

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

   345

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

   346

                #         ^

   347

                # note the double zero after "runtime_", 

   348

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

   349

   350

   351

class HMITreeSelector(wx.TreeCtrl):

   352

    def __init__(self, parent):

   353

        global on_hmitree_update

   354

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

   355

   356

        isz = (16,16)

   357

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

   358

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

   359

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

   360

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

   361

        self.SetImageList(il)

   362

   363

        on_hmitree_update = self.SVGHMIEditorUpdater()

   364

        self.MakeTree()

   365

   366

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   367

        for c in current_hmitree_root.children:

   368

            if hasattr(c, "children"):

   369

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

   370

                               if c.hmiclass is not None else c.name

   371

                tc_child = self.AppendItem(current_tc_root, display_name)

   372

                self.SetPyData(tc_child, None)

   373

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

   374

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

   375

   376

                self._recurseTree(c,tc_child)

   377

            else:

   378

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

   379

                tc_child = self.AppendItem(current_tc_root, display_name)

   380

                self.SetPyData(tc_child, None)

   381

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

   382

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

   383

   384

    def MakeTree(self):

   385

        global hmi_tree_root

   386

   387

        self.Freeze()

   388

   389

        self.root = None

   390

        self.DeleteAllItems()

   391

   392

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

   393

        self.root = self.AddRoot(root_display_name)

   394

        self.SetPyData(self.root, None)

   395

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

   396

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

   397

   398

        if hmi_tree_root is not None:

   399

            self._recurseTree(hmi_tree_root, self.root)

   400

   401

        self.Thaw()

   402

   403

    def SVGHMIEditorUpdater(self):

   404

        selfref = weakref.ref(self)

   405

        def SVGHMIEditorUpdate():

   406

            o = selfref()

   407

            if o is not None:

   408

                wx.CallAfter(o.MakeTree)

   409

        return SVGHMIEditorUpdate

   410

   411

class HMITreeView(wx.SplitterWindow):

   412

   413

    def __init__(self, parent):

   414

        wx.SplitterWindow.__init__(self, parent,

   415

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   416

   417

        self.SelectionTree = HMITreeSelector(self)

   418

        #self.Staging = wx.Panel(self)

   419

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

   420

        self.Initialize(self.SelectionTree)

   421

   422

   423

class SVGHMIEditor(ConfTreeNodeEditor):

   424

    CONFNODEEDITOR_TABS = [

   425

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

   426

   427

    def CreateHMITreeView(self, parent):

   428

        #self.HMITreeView = HMITreeView(self)

   429

        return HMITreeSelector(parent)

   430

   431

   432

class SVGHMI(object):

   433

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

   434

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

   435

      <xsd:element name="SVGHMI">

   436

        <xsd:complexType>

   437

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

   438

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

   439

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

   440

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

   441

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

   442

        </xsd:complexType>

   443

      </xsd:element>

   444

    </xsd:schema>

   445

    """

   446

   447

    EditorType = SVGHMIEditor

   448

   449

    ConfNodeMethods = [

   450

        {

   451

            "bitmap":    "ImportSVG",

   452

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

   453

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

   454

            "method":   "_ImportSVG"

   455

        },

   456

        {

   457

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

   458

            "name":    _("Inkscape"),

   459

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

   460

            "method":   "_StartInkscape"

   461

        },

   462

   463

        # TODO : Launch POEdit button

   464

        #        PO -> SVG layers button

   465

        #        SVG layers -> PO

   466

   467

        # TODO : HMITree button

   468

        #        - can drag'n'drop variabes to Inkscape

   469

   470

    ]

   471

   472

    def _getSVGpath(self, project_path=None):

   473

        if project_path is None:

   474

            project_path = self.CTNPath()

   475

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

   476

   477

   478

    def OnCTNSave(self, from_project_path=None):

   479

        if from_project_path is not None:

   480

            shutil.copyfile(self._getSVGpath(from_project_path),

   481

                            self._getSVGpath())

   482

        return True

   483

   484

    def GetSVGGeometry(self):

   485

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

   486

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

   487

   488

        inkpath = get_inkscape_path()

   489