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

    16

import wx

    17

    18

import util.paths as paths

    19

from POULibrary import POULibrary

    20

from docutil import open_svg, get_inkscape_path

    21

from lxml import etree

    22

    23

from util.ProcessLogger import ProcessLogger

    24

from runtime.typemapping import DebugTypesSize

    25

import targets

    26

    27

HMI_TYPES_DESC = {

    28

    "HMI_NODE":{},

    29

    "HMI_STRING":{},

    30

    "HMI_INT":{},

    31

    "HMI_REAL":{}

    32

}

    33

    34

HMI_TYPES = HMI_TYPES_DESC.keys()

    35

    36

from XSLTransform import XSLTransform

    37

from lxml.etree import XSLTApplyError

    38

    39

ScriptDirectory = paths.AbsDir(__file__)

    40

    41

class HMITreeNode(object):

    42

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

    43

        self.path = path

    44

        self.name = name

    45

        self.nodetype = nodetype

    46

        self.hmiclass = hmiclass

    47

    48

        if iectype is not None:

    49

            self.iectype = iectype

    50

            self.vartype = vartype

    51

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

    52

            self.children = []

    53

    54

    def pprint(self, indent = 0):

    55

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

    56

        if hasattr(self, "children"): 

    57

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

    58

                              for child in self.children])

    59

            res += "\n"

    60

    61

        return res

    62

    63

    def place_node(self, node):

    64

        best_child = None

    65

        known_best_match = 0

    66

        for child in self.children : 

    67

            if child.path is not None:

    68

                in_common = 0

    69

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

    70

                    if child_path_item == node_path_item:

    71

                        in_common +=1

    72

                    else:

    73

                        break

    74

                if in_common > known_best_match:

    75

                    known_best_match = in_common

    76

                    best_child = child

    77

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

    78

            best_child.place_node(node)

    79

        else:

    80

            self.children.append(node)

    81

    82

    def etree(self, add_hash=False):

    83

    84

        attribs = dict(name=self.name)

    85

        if self.path is not None:

    86

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

    87

    91

        if add_hash:

    92

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

    93

    94

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

    95

    96

        if hasattr(self, "children"): 

    97

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

    98

                res.append(child_etree)

    99

   100

        return res

   101

   102

    def traverse(self):

   103

        yield self

   104

        if hasattr(self, "children"): 

   105

            for c in self.children:

   106

                for yoodl in c.traverse():

   107

                    yield yoodl

   108

   109

   110

    def hash(self):

   111

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

   112

        s = hashlib.new('md5')

   113

        self._hash(s)

   114

        # limit size to HMI_HASH_SIZE as in svghmi.c

   115

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

   116

   117

    def _hash(self, s):

   118

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

   119

        if hasattr(self, "children"): 

   120

            for c in self.children:

   121

                c._hash(s)

   122

   123

# module scope for HMITree root

   124

# so that CTN can use HMITree deduced in Library

   125

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

   126

#       systematicaly invoked before CTN's CTNGenerate_C

   127

   128

hmi_tree_root = None

   129

   130

class SVGHMILibrary(POULibrary):

   131

    def GetLibraryPath(self):

   132

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

   133

   134

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

   135

        global hmi_tree_root, hmi_tree_unique_id 

   136

   137

        """

   138

        PLC Instance Tree:

   139

          prog0

   140

           +->v1 HMI_INT

   141

           +->v2 HMI_INT

   142

           +->fb0 (type mhoo)

   143

           |   +->va HMI_NODE

   144

           |   +->v3 HMI_INT

   145

           |   +->v4 HMI_INT

   146

           |

   147

           +->fb1 (type mhoo)

   148

           |   +->va HMI_NODE

   149

           |   +->v3 HMI_INT

   150

           |   +->v4 HMI_INT

   151

           |

   152

           +->fb2

   153

               +->v5 HMI_IN

   154

   155

        HMI tree:

   156

          hmi0

   157

           +->v1

   158

           +->v2

   159

           +->fb0 class:va

   160

           |   +-> v3

   161

           |   +-> v4

   162

           |

   163

           +->fb1 class:va

   164

           |   +-> v3

   165

           |   +-> v4

   166

           |

   167

           +->v5

   168

   169

        """

   170

   171

        # Filter known HMI types

   172

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

   173

   174

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

   175

   176

        # add special nodes 

   177

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

   178

                ("plc_status", "HMI_PLC_STATUS"),

   179

                ("current_page", "HMI_CURRENT_PAGE")])

   180

   181

        # deduce HMI tree from PLC HMI_* instances

   182

        for v in hmi_types_instances:

   183

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

   184

            # ignores variables starting with _TMP_

   185

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

   186

                continue

   187

            derived = v["derived"]

   188

            kwargs={}

   189

            if derived == "HMI_NODE":

   190

                name = path[-2]

   191

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

   192

            else:

   193

                name = path[-1]

   194

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

   195

            hmi_tree_root.place_node(new_node)

   196

   197

        variable_decl_array = []

   198

        extern_variables_declarations = []

   199

        buf_index = 0

   200

        item_count = 0

   201

        for node in hmi_tree_root.traverse():

   202

            if hasattr(node, "iectype") and \

   203

               node.nodetype not in ["HMI_NODE"]:

   204

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

   205

                variable_decl_array += [

   206

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

   207

                        "EXT": "_P_ENUM",

   208

                        "IN":  "_P_ENUM",

   209

                        "MEM": "_O_ENUM",

   210

                        "OUT": "_O_ENUM",

   211

                        "VAR": "_ENUM"

   212

                    }[node.vartype] + ", " +

   213

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

   214

                buf_index += sz

   215

                item_count += 1

   216

                if len(node.path) == 1:

   217

                    extern_variables_declarations += [

   218

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

   219

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

   220

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

   221

   222

        # TODO : filter only requiered external declarations

   223

        for v in varlist :

   224

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

   225

                extern_variables_declarations += [

   226

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

   227

   228

        # TODO check if programs need to be declared separately

   229

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

   230

        #                                     p for p in self._ProgramList]),

   231

   232

        # C code to observe/access HMI tree variables

   233

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

   234

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   235

        svghmi_c_code = svghmi_c_file.read()

   236

        svghmi_c_file.close()

   237

        svghmi_c_code = svghmi_c_code % { 

   238

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

   239

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

   240

            "buffer_size": buf_index,

   241

            "item_count": item_count,

   242

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

   243

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

   244

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

   245

            }

   246

   247

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

   248

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   249

        gen_svghmi_c.write(svghmi_c_code)

   250

        gen_svghmi_c.close()

   251

   252

        # Python based WebSocket HMITree Server

   253

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

   254

        svghmiservercode = svghmiserverfile.read()

   255

        svghmiserverfile.close()

   256

   257

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

   258

        runtimefile = open(runtimefile_path, 'w')

   259

        runtimefile.write(svghmiservercode)

   260

        runtimefile.close()

   261

   262

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

   263

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

   264

   265

class SVGHMI(object):

   266

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

   267

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

   268

      <xsd:element name="SVGHMI">

   269

        <xsd:complexType>

   270

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

   271

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

   272

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

   273

        </xsd:complexType>

   274

      </xsd:element>

   275

    </xsd:schema>

   276

    """

   277

    # TODO : add comma separated supported language list

   278

   279

    ConfNodeMethods = [

   280

        {

   281

            "bitmap":    "ImportSVG",

   282

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

   283

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

   284

            "method":   "_ImportSVG"

   285

        },

   286

        {

   287

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

   288

            "name":    _("Inkscape"),

   289

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

   290

            "method":   "_StartInkscape"

   291

        },

   292

   293

        # TODO : Launch POEdit button

   294

        #        PO -> SVG layers button

   295

        #        SVG layers -> PO

   296

   297

        # TODO : HMITree button

   298

        #        - can drag'n'drop variabes to Inkscape

   299

   300

    ]

   301

   302

    def _getSVGpath(self, project_path=None):

   303

        if project_path is None:

   304

            project_path = self.CTNPath()

   305

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

   306

   307

   308

    def OnCTNSave(self, from_project_path=None):

   309

        if from_project_path is not None:

   310

            shutil.copyfile(self._getSVGpath(from_project_path),

   311

                            self._getSVGpath())

   312

        return True

   313

   314

    def GetSVGGeometry(self):

   315

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

   316

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

   317

   318

        inkpath = get_inkscape_path()

   319

        svgpath = self._getSVGpath()

   320

        _status, result, _err_result = ProcessLogger(None,

   321

                                                     inkpath + " -S " + svgpath,

   322

                                                     no_stdout=True,

   323

                                                     no_stderr=True).spin()

   324

        res = []

   325

        for line in result.split():

   326

            strippedline = line.strip()

   327

            attrs = dict(

   328

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

   329

   330

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

   331

   332

        return res

   333

   334

    def GetHMITree(self):

   335

        global hmi_tree_root

   336

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

   337

        return res

   338

   339

    def CTNGenerate_C(self, buildpath, locations):

   340

        """

   341

        Return C code generated by iec2c compiler

   342

        when _generate_softPLC have been called

   343

        @param locations: ignored

   344

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

   345

        """

   346

   347

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

   348

        view_name = self.BaseParams.getName()

   349

   350

        svgfile = self._getSVGpath()

   351

   352

        res = ([], "", False)

   353

   354

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

   355

   356

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

   357

        target_file = open(target_path, 'wb')

   358

   359

        if os.path.exists(svgfile):

   360

   361

            # TODO : move to __init__

   362

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

   363

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

   364

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

   365

   366

   367

            # load svg as a DOM with Etree

   368

            svgdom = etree.parse(svgfile)

   369

   370

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

   371

            try:

   372

                result = transform.transform(svgdom)

   373

            except XSLTApplyError as e:

   374

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

   375

   376

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

   377

            # print(str(result))

   378

            # print(transform.xslt.error_log)

   379

   380

            # TODO

   381

            #   - Errors on HMI semantics

   382

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

   383

   384

        else:

   385

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

   386

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

   387

<html>

   388

<body>

   389

<h1> No SVG file provided </h1>

   390

</body>

   391

</html>

   392

""")

   393

   394

        target_file.close()

   395

   396

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

   397

   398

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

   399

        runtimefile = open(runtimefile_path, 'w')

   400

        runtimefile.write("""

   401

def _runtime_svghmi1_%(location)s_start():

   402

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

   403

   404

def _runtime_svghmi1_%(location)s_stop():

   405

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

   406

   407

        """ % {"location": location_str,

   408

               "xhtml": target_fname,

   409

               "view_name": view_name})

   410

   411

        runtimefile.close()

   412

   413

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

   414

   415

        return res

   416

   417

    def _ImportSVG(self):

   418

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

   419

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

   420

            svgpath = dialog.GetPath()

   421

            if os.path.isfile(svgpath):

   422

                shutil.copy(svgpath, self._getSVGpath())

   423

            else:

   424

                self.GetCTRoot().logger.write_error(_("No such SVG file: %s\n") % svgpath)

   425

        dialog.Destroy()

   426

   427

    def _StartInkscape(self):

   428

        svgfile = self._getSVGpath()

   429

        open_inkscape = True

   430

        if not self.GetCTRoot().CheckProjectPathPerm():

   431

            dialog = wx.MessageDialog(self.GetCTRoot().AppFrame,

   432

                                      _("You don't have write permissions.\nOpen Inkscape anyway ?"),

   433

                                      _("Open Inkscape"),

   434

                                      wx.YES_NO | wx.ICON_QUESTION)

   435

            open_inkscape = dialog.ShowModal() == wx.ID_YES

   436

            dialog.Destroy()

   437

        if open_inkscape:

   438

            if not os.path.isfile(svgfile):

   439

                svgfile = None

   440

            open_svg(svgfile)