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 pprint, pformat

    14

import hashlib

    15

import weakref

    16

    17

import wx

    18

import wx.dataview as dv

    19

    20

from lxml import etree

    21

from lxml.etree import XSLTApplyError

    22

    23

import util.paths as paths

    24

from POULibrary import POULibrary

    25

from docutil import open_svg, get_inkscape_path

    26

    27

from util.ProcessLogger import ProcessLogger

    28

from runtime.typemapping import DebugTypesSize

    29

import targets

    30

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    31

from XSLTransform import XSLTransform

    32

    33

HMI_TYPES_DESC = {

    34

    "HMI_NODE":{},

    35

    "HMI_STRING":{},

    36

    "HMI_INT":{},

    37

    "HMI_REAL":{}

    38

}

    39

    40

HMI_TYPES = HMI_TYPES_DESC.keys()

    41

    42

    43

ScriptDirectory = paths.AbsDir(__file__)

    44

    45

class HMITreeNode(object):

    46

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

    47

        self.path = path

    48

        self.name = name

    49

        self.nodetype = nodetype

    50

        self.hmiclass = hmiclass

    51

    52

        if iectype is not None:

    53

            self.iectype = iectype

    54

            self.vartype = vartype

    55

        if nodetype in ["HMI_NODE", "HMI_ROOT"]:

    56

            self.children = []

    57

    58

    def pprint(self, indent = 0):

    59

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

    60

        if hasattr(self, "children"):

    61

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

    62

                              for child in self.children])

    63

            res += "\n"

    64

    65

        return res

    66

    67

    def place_node(self, node):

    68

        best_child = None

    69

        known_best_match = 0

    70

        for child in self.children:

    71

            if child.path is not None:

    72

                in_common = 0

    73

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

    74

                    if child_path_item == node_path_item:

    75

                        in_common +=1

    76

                    else:

    77

                        break

    78

                if in_common > known_best_match:

    79

                    known_best_match = in_common

    80

                    best_child = child

    81

        if best_child is not None and best_child.nodetype == "HMI_NODE":

    82

            best_child.place_node(node)

    83

        else:

    84

            self.children.append(node)

    85

    86

    def etree(self, add_hash=False):

    87

    88

        attribs = dict(name=self.name)

    89

        if self.path is not None:

    90

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

    91

    92

        if self.hmiclass is not None:

    93

            attribs["class"] = self.hmiclass

    94

    95

        if add_hash:

    96

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

    97

    98

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

    99

   100

        if hasattr(self, "children"):

   101

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

   102

                res.append(child_etree)

   103

   104

        return res

   105

   106

    def traverse(self):

   107

        yield self

   108

        if hasattr(self, "children"):

   109

            for c in self.children:

   110

                for yoodl in c.traverse():

   111

                    yield yoodl

   112

   113

   114

    def hash(self):

   115

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

   116

        s = hashlib.new('md5')

   117

        self._hash(s)

   118

        # limit size to HMI_HASH_SIZE as in svghmi.c

   119

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

   120

   121

    def _hash(self, s):

   122

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

   123

        if hasattr(self, "children"):

   124

            for c in self.children:

   125

                c._hash(s)

   126

   127

# module scope for HMITree root

   128

# so that CTN can use HMITree deduced in Library

   129

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

   130

#       systematicaly invoked before CTN's CTNGenerate_C

   131

   132

hmi_tree_root = None

   133

   134

on_hmitree_update = None

   135

   136

class SVGHMILibrary(POULibrary):

   137

    def GetLibraryPath(self):

   138

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

   139

   140

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

   141

        global hmi_tree_root, on_hmitree_update, hmi_tree_unique_id

   142

   143

        """

   144

        PLC Instance Tree:

   145

          prog0

   146

           +->v1 HMI_INT

   147

           +->v2 HMI_INT

   148

           +->fb0 (type mhoo)

   149

           |   +->va HMI_NODE

   150

           |   +->v3 HMI_INT

   151

           |   +->v4 HMI_INT

   152

           |

   153

           +->fb1 (type mhoo)

   154

           |   +->va HMI_NODE

   155

           |   +->v3 HMI_INT

   156

           |   +->v4 HMI_INT

   157

           |

   158

           +->fb2

   159

               +->v5 HMI_IN

   160

   161

        HMI tree:

   162

          hmi0

   163

           +->v1

   164

           +->v2

   165

           +->fb0 class:va

   166

           |   +-> v3

   167

           |   +-> v4

   168

           |

   169

           +->fb1 class:va

   170

           |   +-> v3

   171

           |   +-> v4

   172

           |

   173

           +->v5

   174

   175

        """

   176

   177

        # Filter known HMI types

   178

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

   179

   180

        hmi_tree_root = HMITreeNode(None, "/", "HMI_ROOT")

   181

   182

        # add special nodes

   183

        map(lambda (n,t): hmi_tree_root.children.append(HMITreeNode(None,n,t)), [

   184

                ("plc_status", "HMI_PLC_STATUS"),

   185

                ("current_page", "HMI_CURRENT_PAGE")])

   186

   187

        # deduce HMI tree from PLC HMI_* instances

   188

        for v in hmi_types_instances:

   189

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

   190

            # ignores variables starting with _TMP_

   191

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

   192

                continue

   193

            derived = v["derived"]

   194

            kwargs={}

   195

            if derived == "HMI_NODE":

   196

                name = path[-2]

   197

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

   198

            else:

   199

                name = path[-1]

   200

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

   201

            hmi_tree_root.place_node(new_node)

   202

   203

        if on_hmitree_update is not None:

   204

            on_hmitree_update()

   205

   206

        variable_decl_array = []

   207

        extern_variables_declarations = []

   208

        buf_index = 0

   209

        item_count = 0

   210

        for node in hmi_tree_root.traverse():

   211

            if hasattr(node, "iectype") and \

   212

               node.nodetype not in ["HMI_NODE"]:

   213

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

   214

                variable_decl_array += [

   215

                    "{&(" + ".".join(node.path) + "), " + node.iectype + {

   216

                        "EXT": "_P_ENUM",

   217

                        "IN":  "_P_ENUM",

   218

                        "MEM": "_O_ENUM",

   219

                        "OUT": "_O_ENUM",

   220

                        "VAR": "_ENUM"

   221

                    }[node.vartype] + ", " +

   222

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

   223

                buf_index += sz

   224

                item_count += 1

   225

                if len(node.path) == 1:

   226

                    extern_variables_declarations += [

   227

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

   228

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

   229

                        + ".".join(node.path) + ";"]

   230

   231

        # TODO : filter only requiered external declarations

   232

        for v in varlist :

   233

            if v["C_path"].find('.') < 0 and v["vartype"] == "FB" :

   234

                extern_variables_declarations += [

   235

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

   236

   237

        # TODO check if programs need to be declared separately

   238

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

   239

        #                                     p for p in self._ProgramList]),

   240

   241

        # C code to observe/access HMI tree variables

   242

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

   243

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   244

        svghmi_c_code = svghmi_c_file.read()

   245

        svghmi_c_file.close()

   246

        svghmi_c_code = svghmi_c_code % {

   247

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

   248

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

   249

            "buffer_size": buf_index,

   250

            "item_count": item_count,

   251

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

   252

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

   253

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

   254

            }

   255

   256

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

   257

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   258

        gen_svghmi_c.write(svghmi_c_code)

   259

        gen_svghmi_c.close()

   260

   261

        # Python based WebSocket HMITree Server

   262

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

   263

        svghmiservercode = svghmiserverfile.read()

   264

        svghmiserverfile.close()

   265

   266

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

   267

        runtimefile = open(runtimefile_path, 'w')

   268

        runtimefile.write(svghmiservercode)

   269

        runtimefile.close()

   270

   271

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

   272

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

   273

   274

   326

   327

    def SVGHMIEditorUpdater(self):

   328

        selfref = weakref.ref(self)

   329

        def SVGHMIEditorUpdate():

   330

            o = selfref()

   331

            if o is not None:

   332

                wx.CallAfter(o.MakeTree)

   333

        return SVGHMIEditorUpdate

   334

   351

    def CreateHMITreeView(self, parent):

   355

   356

class SVGHMI(object):

   357

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

   358

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

   359

      <xsd:element name="SVGHMI">

   360

        <xsd:complexType>

   361

          <xsd:attribute name="enableHTTP" type="xsd:boolean" use="optional" default="false"/>

   362

          <xsd:attribute name="bindAddress" type="xsd:string" use="optional" default="localhost"/>

   363

          <xsd:attribute name="port" type="xsd:string" use="optional" default="8080"/>

   364

        </xsd:complexType>

   365

      </xsd:element>

   366

    </xsd:schema>

   367

    """

   368

   369

    EditorType = SVGHMIEditor

   370

   371

    ConfNodeMethods = [

   372

        {

   373

            "bitmap":    "ImportSVG",

   374

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

   375

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

   376

            "method":   "_ImportSVG"

   377

        },

   378

        {

   379

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

   380

            "name":    _("Inkscape"),

   381

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

   382

            "method":   "_StartInkscape"

   383

        },

   384

   385

        # TODO : Launch POEdit button

   386

        #        PO -> SVG layers button

   387

        #        SVG layers -> PO

   388

   389

        # TODO : HMITree button

   390

        #        - can drag'n'drop variabes to Inkscape

   391

   392

    ]

   393

   394

    def _getSVGpath(self, project_path=None):

   395

        if project_path is None:

   396

            project_path = self.CTNPath()

   397

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

   398

   399

   400

    def OnCTNSave(self, from_project_path=None):

   401

        if from_project_path is not None:

   402

            shutil.copyfile(self._getSVGpath(from_project_path),

   403

                            self._getSVGpath())

   404

        return True

   405

   406

    def GetSVGGeometry(self):

   407

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

   408

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

   409

   410

        inkpath = get_inkscape_path()

   411

        svgpath = self._getSVGpath()

   412

        _status, result, _err_result = ProcessLogger(None,

   413

                                                     inkpath + " -S " + svgpath,

   414

                                                     no_stdout=True,

   415

                                                     no_stderr=True).spin()

   416

        res = []

   417

        for line in result.split():

   418

            strippedline = line.strip()

   419

            attrs = dict(

   420

                zip(InkscapeGeomColumns, line.strip().split(',')))

   421

   422

            res.append(etree.Element("bbox", **attrs))

   423

   424

        return res

   425

   426

    def GetHMITree(self):

   427

        global hmi_tree_root

   428

        res = [hmi_tree_root.etree(add_hash=True)]

   429

        return res

   430

   431

    def CTNGenerate_C(self, buildpath, locations):

   432

        """

   433

        Return C code generated by iec2c compiler

   434

        when _generate_softPLC have been called

   435

        @param locations: ignored

   436

        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   437

        """

   438

   439

        location_str = "_".join(map(str, self.GetCurrentLocation()))

   440

        view_name = self.BaseParams.getName()

   441

   442

        svgfile = self._getSVGpath()

   443

   444

        res = ([], "", False)

   445

   446

        target_fname = "svghmi_"+location_str+".xhtml"

   447

   448

        target_path = os.path.join(self._getBuildPath(), target_fname)

   449

        target_file = open(target_path, 'wb')

   450

   451

        if os.path.exists(svgfile):

   452

   453

            # TODO : move to __init__

   454

            transform = XSLTransform(os.path.join(ScriptDirectory, "gen_index_xhtml.xslt"),

   455

                          [("GetSVGGeometry", lambda *_ignored:self.GetSVGGeometry()),

   456

                           ("GetHMITree", lambda *_ignored:self.GetHMITree())])

   457

   458

   459

            # load svg as a DOM with Etree

   460

            svgdom = etree.parse(svgfile)

   461

   462

            # call xslt transform on Inkscape's SVG to generate XHTML

   463

            try:

   464

                result = transform.transform(svgdom)

   465

            except XSLTApplyError as e:

   466

                self.FatalError("SVGHMI " + view_name  + ": " + e.message)

   467

   468

            result.write(target_file, encoding="utf-8")

   469

            # print(str(result))

   470

            # print(transform.xslt.error_log)

   471

   472

            # TODO

   473

            #   - Errors on HMI semantics

   474

            #   - ... maybe something to have a global view of what is declared in SVG.

   475

   476

        else:

   477

            # TODO : use default svg that expose the HMI tree as-is

   478

            target_file.write("""<!DOCTYPE html>

   479

<html>

   480

<body>

   481

<h1> No SVG file provided </h1>

   482

</body>

   483

</html>

   484

""")

   485

   486

        target_file.close()

   487

   488

        res += ((target_fname, open(target_path, "rb")),)

   489

   490

        runtimefile_path = os.path.join(buildpath, "runtime_svghmi1_%s.py" % location_str)

   491

        runtimefile = open(runtimefile_path, 'w')