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

    16

    17

import wx

    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

    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

   136

class SVGHMILibrary(POULibrary):

   137

    def GetLibraryPath(self):

   138

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

   139

   140

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

   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

   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

   337

class SVGHMI(object):

   338

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

   339

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

   340

      <xsd:element name="SVGHMI">

   341

        <xsd:complexType>

   342

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

   343

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

   344

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

   345

        </xsd:complexType>

   346

      </xsd:element>

   347

    </xsd:schema>

   348

    """

   351

   352

    ConfNodeMethods = [

   353

        {

   354

            "bitmap":    "ImportSVG",

   355

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

   356

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

   357

            "method":   "_ImportSVG"

   358

        },

   359

        {

   360

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

   361

            "name":    _("Inkscape"),

   362

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

   363

            "method":   "_StartInkscape"

   364

        },

   365

   366

        # TODO : Launch POEdit button

   367

        #        PO -> SVG layers button

   368

        #        SVG layers -> PO

   369

   370

        # TODO : HMITree button

   371

        #        - can drag'n'drop variabes to Inkscape

   372

   373

    ]

   374

   375

    def _getSVGpath(self, project_path=None):

   376

        if project_path is None:

   377

            project_path = self.CTNPath()

   378

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

   379

   380

   381

    def OnCTNSave(self, from_project_path=None):

   382

        if from_project_path is not None:

   383

            shutil.copyfile(self._getSVGpath(from_project_path),

   384

                            self._getSVGpath())

   385

        return True

   386

   387

    def GetSVGGeometry(self):

   388

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

   389

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

   390

   391

        inkpath = get_inkscape_path()

   392

        svgpath = self._getSVGpath()

   393

        _status, result, _err_result = ProcessLogger(None,

   394

                                                     inkpath + " -S " + svgpath,

   395

                                                     no_stdout=True,

   396

                                                     no_stderr=True).spin()

   397

        res = []

   398

        for line in result.split():

   399

            strippedline = line.strip()

   400

            attrs = dict(

   401

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

   402

   403

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

   404

   405

        return res

   406

   407

    def GetHMITree(self):

   408

        global hmi_tree_root

   409

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

   410

        return res

   411

   412

    def CTNGenerate_C(self, buildpath, locations):

   413

        """

   414

        Return C code generated by iec2c compiler

   415

        when _generate_softPLC have been called

   416

        @param locations: ignored

   417

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

   418

        """

   419

   420

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

   421

        view_name = self.BaseParams.getName()

   422

   423

        svgfile = self._getSVGpath()

   424

   425

        res = ([], "", False)

   426

   427

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

   428

   429

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

   430

        target_file = open(target_path, 'wb')

   431

   432

        if os.path.exists(svgfile):

   433

   434

            # TODO : move to __init__

   435

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

   436

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

   437

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

   438

   439

   440

            # load svg as a DOM with Etree

   441

            svgdom = etree.parse(svgfile)

   442

   443

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

   444

            try:

   445

                result = transform.transform(svgdom)

   446

            except XSLTApplyError as e:

   447

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

   448

   449

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

   450

            # print(str(result))

   451

            # print(transform.xslt.error_log)

   452

   453

            # TODO

   454

            #   - Errors on HMI semantics

   455

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

   456

   457

        else:

   458

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

   459

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

   460

<html>

   461

<body>

   462

<h1> No SVG file provided </h1>

   463

</body>

   464

</html>

   465

""")

   466

   467

        target_file.close()

   468

   469

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

   470

   471

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

   472

        runtimefile = open(runtimefile_path, 'w')

   473

        runtimefile.write("""

   474

def _runtime_svghmi1_%(location)s_start():

   475

    svghmi_root.putChild('%(view_name)s',File('%(xhtml)s', defaultType='application/xhtml+xml'))

   476

   477

def _runtime_svghmi1_%(location)s_stop():

   478

    svghmi_root.delEntity('%(view_name)s')

   479

   480

        """ % {"location": location_str,

   481

               "xhtml": target_fname,

   482

               "view_name": view_name})

   483

   484

        runtimefile.close()

   485

   486

        res += (("runtime_svghmi1_%s.py" % location_str, open(runtimefile_path, "rb")),)

   487

   488

        return res

   489

   490

    def _ImportSVG(self):

   491

        dialog = wx.FileDialog(self.GetCTRoot().AppFrame, _("Choose a SVG file"), os.getcwd(), "",  _("SVG files (*.svg)|*.svg|All files|*.*"), wx.OPEN)

   492

        if dialog.ShowModal() == wx.ID_OK:

   493