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

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

    34

    35

HMI_TYPES_DESC = {

    36

    "HMI_NODE":{},

    37

    "HMI_STRING":{},

    38

    "HMI_INT":{},

    39

    "HMI_BOOL":{},

    40

    "HMI_REAL":{}

    41

}

    42

    43

HMI_TYPES = HMI_TYPES_DESC.keys()

    44

    45

    46

ScriptDirectory = paths.AbsDir(__file__)

    47

    48

class HMITreeNode(object):

    49

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

    50

        self.path = path

    51

        self.name = name

    52

        self.nodetype = nodetype

    53

        self.hmiclass = hmiclass

    54

    55

        if iectype is not None:

    56

            self.iectype = iectype

    57

            self.vartype = vartype

    58

            self.cpath = cpath

    59

    60

        if nodetype in ["HMI_NODE"]:

    61

            self.children = []

    62

    63

    def pprint(self, indent = 0):

    64

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

    65

        if hasattr(self, "children"):

    66

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

    67

                              for child in self.children])

    68

            res += "\n"

    69

    70

        return res

    71

    72

    def place_node(self, node):

    73

        best_child = None

    74

        known_best_match = 0

    75

        potential_siblings = {}

    76

        for child in self.children:

    77

            if child.path is not None:

    78

                in_common = 0

    79

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

    80

                    if child_path_item == node_path_item:

    81

                        in_common +=1

    82

                    else:

    83

                        break

    84

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

    85

                # must match candidate node (except for name part)

    86

                # since candidate would become child of that node

    87

                if in_common > known_best_match and \

    88

                   child.nodetype == "HMI_NODE" and \

    89

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

    90

                    known_best_match = in_common

    91

                    best_child = child

    92

                else:

    93

                    potential_siblings[child.path[

    94

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

    95

        if best_child is not None:

    96

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

    97

                return "Duplicate_HMI_NODE", best_child

    98

            return best_child.place_node(node)

    99

        else:

   100

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

   101

            if candidate_name in potential_siblings:

   102

                return "Non_Unique", potential_siblings[candidate_name]

   103

   104

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

   105

                prev = self.children[-1]

   106

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

   107

                    return "Late_HMI_NODE",prev

   108

   109

            self.children.append(node)

   110

            return None

   111

   112

    def etree(self, add_hash=False):

   113

   114

        attribs = dict(name=self.name)

   115

        if self.path is not None:

   116

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

   117

   118

        if self.hmiclass is not None:

   119

            attribs["class"] = self.hmiclass

   120

   121

        if add_hash:

   122

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

   123

   124

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

   125

   126

        if hasattr(self, "children"):

   127

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

   128

                res.append(child_etree)

   129

   130

        return res

   131

   132

    def traverse(self):

   133

        yield self

   134

        if hasattr(self, "children"):

   135

            for c in self.children:

   136

                for yoodl in c.traverse():

   137

                    yield yoodl

   138

   139

   140

    def hash(self):

   141

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

   142

        s = hashlib.new('md5')

   143

        self._hash(s)

   144

        # limit size to HMI_HASH_SIZE as in svghmi.c

   145

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

   146

   147

    def _hash(self, s):

   148

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

   149

        if hasattr(self, "children"):

   150

            for c in self.children:

   151

                c._hash(s)

   152

   153

# module scope for HMITree root

   154

# so that CTN can use HMITree deduced in Library

   155

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

   156

#       systematicaly invoked before CTN's CTNGenerate_C

   157

   158

hmi_tree_root = None

   159

   160

on_hmitree_update = None

   161

   162

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

   163

                 ("heartbeat", "HMI_INT")]

   164

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

   165

   166

class SVGHMILibrary(POULibrary):

   167

    def GetLibraryPath(self):

   168

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

   169

   170

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

   171

        global hmi_tree_root, on_hmitree_update

   172

   173

        """

   174

        PLC Instance Tree:

   175

          prog0

   176

           +->v1 HMI_INT

   177

           +->v2 HMI_INT

   178

           +->fb0 (type mhoo)

   179

           |   +->va HMI_NODE

   180

           |   +->v3 HMI_INT

   181

           |   +->v4 HMI_INT

   182

           |

   183

           +->fb1 (type mhoo)

   184

           |   +->va HMI_NODE

   185

           |   +->v3 HMI_INT

   186

           |   +->v4 HMI_INT

   187

           |

   188

           +->fb2

   189

               +->v5 HMI_IN

   190

   191

        HMI tree:

   192

          hmi0

   193

           +->v1

   194

           +->v2

   195

           +->fb0 class:va

   196

           |   +-> v3

   197

           |   +-> v4

   198

           |

   199

           +->fb1 class:va

   200

           |   +-> v3

   201

           |   +-> v4

   202

           |

   203

           +->v5

   204

   205

        """

   206

   207

        # Filter known HMI types

   208

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

   209

   210

        hmi_tree_root = None

   211

   212

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

   213

        for i,v in enumerate(hmi_types_instances):

   214

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

   215

            derived = v["derived"]

   216

            if derived == "HMI_NODE":

   217

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

   218

                hmi_types_instances.pop(i)

   219

                break

   220

   221

        if hmi_tree_root is None:

   222

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

   223

   224

        # deduce HMI tree from PLC HMI_* instances

   225

        for v in hmi_types_instances:

   226

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

   227

            # ignores variables starting with _TMP_

   228

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

   229

                continue

   230

            derived = v["derived"]

   231

            kwargs={}

   232

            if derived == "HMI_NODE":

   233

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

   234

                name = path[-2]

   235

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

   236

            else:

   237

                name = path[-1]

   238

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

   239

            placement_result = hmi_tree_root.place_node(new_node)

   240

            if placement_result is not None:

   241

                cause, problematic_node = placement_result

   242

                if cause == "Non_Unique":

   243

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

   244

                        ".".join(problematic_node.path),

   245

                        ".".join(new_node.path))

   246

   247

                    last_FB = None 

   248

                    for v in varlist:

   249

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

   250

                            last_FB = v 

   251

                        if v["C_path"] == problematic_node:

   252

                            break

   253

                    if last_FB is not None:

   254

                        failing_parent = last_FB["type"]

   255

                        message += "\n"

   256

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

   257

   258

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

   259

                    cause, problematic_node = placement_result

   260

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

   261

                        ".".join(problematic_node.path),

   262

                        ".".join(new_node.path))

   263

   264

                self.FatalError("SVGHMI : " + message)

   265

   266

        if on_hmitree_update is not None:

   267

            on_hmitree_update()

   268

   269

        variable_decl_array = []

   270

        extern_variables_declarations = []

   271

        buf_index = 0

   272

        item_count = 0

   273

        found_heartbeat = False

   274

   275

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   276

   277

        for node in hmi_tree_root.traverse():

   278

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   279

                hmi_tree_hearbeat_index = item_count

   280

                found_heartbeat = True

   281

                extern_variables_declarations += [

   282

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   283

                ]

   284

            if hasattr(node, "iectype"):

   285

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

   286

                variable_decl_array += [

   287

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

   288

                        "EXT": "_P_ENUM",

   289

                        "IN":  "_P_ENUM",

   290

                        "MEM": "_O_ENUM",

   291

                        "OUT": "_O_ENUM",

   292

                        "VAR": "_ENUM"

   293

                    }[node.vartype] + ", " +

   294

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

   295

                buf_index += sz

   296

                item_count += 1

   297

                if len(node.path) == 1:

   298

                    extern_variables_declarations += [

   299

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

   300

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

   301

                        + node.cpath + ";"]

   302

   303

        assert(found_heartbeat)

   304

   305

        # TODO : filter only requiered external declarations

   306

        for v in varlist:

   307

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

   308

                extern_variables_declarations += [

   309

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

   310

   311

        # TODO check if programs need to be declared separately

   312

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

   313

        #                                     p for p in self._ProgramList]),

   314

   315

        # C code to observe/access HMI tree variables

   316

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

   317

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   318

        svghmi_c_code = svghmi_c_file.read()

   319

        svghmi_c_file.close()

   320

        svghmi_c_code = svghmi_c_code % {

   321

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

   322

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

   323

            "buffer_size": buf_index,

   324

            "item_count": item_count,

   325

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

   326

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

   327

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

   328

            }

   329

   330

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

   331

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   332

        gen_svghmi_c.write(svghmi_c_code)

   333

        gen_svghmi_c.close()

   334

   335

        # Python based WebSocket HMITree Server

   336

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

   337

        svghmiservercode = svghmiserverfile.read()

   338

        svghmiserverfile.close()

   339

   340

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

   341

        runtimefile = open(runtimefile_path, 'w')

   342

        runtimefile.write(svghmiservercode)

   343

        runtimefile.close()

   344

   345

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

   346

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

   347

                #         ^

   348

                # note the double zero after "runtime_", 

   349

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

   350

   351

   352

class HMITreeSelector(wx.TreeCtrl):

   353

    def __init__(self, parent):

   354

        global on_hmitree_update

   355

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

   356

   357

        isz = (16,16)

   358

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

   359

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

   360

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

   361

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

   362

        self.SetImageList(il)

   363

   364

        on_hmitree_update = self.SVGHMIEditorUpdater()

   365

        self.MakeTree()

   366

   367

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   368

        for c in current_hmitree_root.children:

   369

            if hasattr(c, "children"):

   370

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

   371

                               if c.hmiclass is not None else c.name

   372

                tc_child = self.AppendItem(current_tc_root, display_name)

   373

                self.SetPyData(tc_child, None)

   374

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

   375

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

   376

   377

                self._recurseTree(c,tc_child)

   378

            else:

   379

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

   380

                tc_child = self.AppendItem(current_tc_root, display_name)

   381

                self.SetPyData(tc_child, None)

   382

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

   383

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

   384

   385

    def MakeTree(self):

   386

        global hmi_tree_root

   387

   388

        self.Freeze()

   389

   390

        self.root = None

   391

        self.DeleteAllItems()

   392

   393

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

   394

        self.root = self.AddRoot(root_display_name)

   395

        self.SetPyData(self.root, None)

   396

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

   397

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

   398

   399

        if hmi_tree_root is not None:

   400

            self._recurseTree(hmi_tree_root, self.root)

   401

   402

        self.Thaw()

   403

   404

    def SVGHMIEditorUpdater(self):

   405

        selfref = weakref.ref(self)

   406

        def SVGHMIEditorUpdate():

   407

            o = selfref()

   408

            if o is not None:

   409

                wx.CallAfter(o.MakeTree)

   410

        return SVGHMIEditorUpdate

   411

   412

class HMITreeView(wx.SplitterWindow):

   413

   414

    def __init__(self, parent):

   415

        wx.SplitterWindow.__init__(self, parent,

   416

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   417

   418

        self.SelectionTree = HMITreeSelector(self)

   419

        #self.Staging = wx.Panel(self)

   420

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

   421

        self.Initialize(self.SelectionTree)

   422

   423

   424

class SVGHMIEditor(ConfTreeNodeEditor):

   425

    CONFNODEEDITOR_TABS = [

   426

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

   427

   428

    def CreateHMITreeView(self, parent):

   429

        #self.HMITreeView = HMITreeView(self)

   430

        return HMITreeSelector(parent)

   431

   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