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_CLASS":{},

    29

    "HMI_LABEL":{},

    30

    "HMI_STRING":{},

    31

    "HMI_INT":{},

    32

    "HMI_REAL":{}

    33

}

    34

    35

HMI_TYPES = HMI_TYPES_DESC.keys()

    36

    37

from XSLTransform import XSLTransform

    38

    39

ScriptDirectory = paths.AbsDir(__file__)

    40

    41

class HMITreeNode(object):

    42

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

    43

        self.path = path

    44

        self.name = name

    45

        self.nodetype = nodetype

    46

    47

        if iectype is not None:

    48

            self.iectype = iectype

    49

            self.vartype = vartype

    50

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

    51

            self.children = []

    52

    53

    def pprint(self, indent = 0):

    54

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

    55

        if hasattr(self, "children"): 

    56

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

    57

                              for child in self.children])

    58

            res += "\n"

    59

    60

        return res

    61

    62

    def place_node(self, node):

    63

        best_child = None

    64

        known_best_match = 0

    65

        for child in self.children : 

    66

            if child.path is not None:

    67

                in_common = 0

    68

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

    69

                    if child_path_item == node_path_item:

    70

                        in_common +=1

    71

                    else:

    72

                        break

    73

                if in_common > known_best_match:

    74

                    known_best_match = in_common

    75

                    best_child = child

    76

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

    77

            best_child.place_node(node)

    78

        else:

    79

            self.children.append(node)

    80

    81

    def etree(self, add_hash=False):

    82

    83

        attribs = dict(name=self.name)

    84

        if self.path is not None:

    85

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

    86

    87

        if add_hash:

    88

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

    89

    90

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

    91

    92

        if hasattr(self, "children"): 

    93

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

    94

                res.append(child_etree)

    95

    96

        return res

    97

    98

    def traverse(self):

    99

        yield self

   100

        if hasattr(self, "children"): 

   101

            for c in self.children:

   102

                for yoodl in c.traverse():

   103

                    yield yoodl

   104

   105

   106

    def hash(self):

   107

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

   108

        s = hashlib.new('md5')

   109

        self._hash(s)

   110

        # limit size to HMI_HASH_SIZE as in svghmi.c

   111

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

   112

   113

    def _hash(self, s):

   114

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

   115

        if hasattr(self, "children"): 

   116

            for c in self.children:

   117

                c._hash(s)

   118

   119

# module scope for HMITree root

   120

# so that CTN can use HMITree deduced in Library

   121

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

   122

#       systematicaly invoked before CTN's CTNGenerate_C

   123

   124

hmi_tree_root = None

   125

   126

class SVGHMILibrary(POULibrary):

   127

    def GetLibraryPath(self):

   128

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

   129

   130

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

   131

        global hmi_tree_root, hmi_tree_unique_id 

   132

   133

        """

   134

        PLC Instance Tree:

   135

          prog0

   136

           +->v1 HMI_INT

   137

           +->v2 HMI_INT

   138

           +->fb0 (type mhoo)

   139

           |   +->va HMI_LABEL

   140

           |   +->v3 HMI_INT

   141

           |   +->v4 HMI_INT

   142

           |

   143

           +->fb1 (type mhoo)

   144

           |   +->va HMI_LABEL

   145

           |   +->v3 HMI_INT

   146

           |   +->v4 HMI_INT

   147

           |

   148

           +->fb2

   149

               +->v5 HMI_IN

   150

   151

        HMI tree:

   152

          hmi0

   153

           +->v1

   154

           +->v2

   155

           +->fb0_va

   156

           |   +-> v3

   157

           |   +-> v4

   158

           |

   159

           +->fb1_va

   160

           |   +-> v3

   161

           |   +-> v4

   162

           |

   163

           +->v5

   164

   165

        """

   166

   167

        # Filter known HMI types

   168

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

   169

   170

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

   171

   172

        # add special nodes 

   173

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

   174

                ("plc_status", "HMI_PLC_STATUS"),

   175

                ("current_page", "HMI_CURRENT_PAGE")])

   176

   177

        # deduce HMI tree from PLC HMI_* instances

   178

        for v in hmi_types_instances:

   179

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

   180

            # ignores variables starting with _TMP_

   181

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

   182

                continue

   183

            new_node = HMITreeNode(path, path[-1], v["derived"], v["type"], v["vartype"])

   184

            hmi_tree_root.place_node(new_node)

   185

   186

        variable_decl_array = []

   187

        extern_variables_declarations = []

   188

        buf_index = 0

   189

        item_count = 0

   190

        for node in hmi_tree_root.traverse():

   191

            if hasattr(node, "iectype") and \

   192

               node.nodetype not in ["HMI_CLASS", "HMI_LABEL"]:

   193

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

   194

                variable_decl_array += [

   195

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

   196

                        "EXT": "_P_ENUM",

   197

                        "IN":  "_P_ENUM",

   198

                        "MEM": "_O_ENUM",

   199

                        "OUT": "_O_ENUM",

   200

                        "VAR": "_ENUM"

   201

                    }[node.vartype] + ", " +

   202

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

   203

                buf_index += sz

   204

                item_count += 1

   205

                if len(node.path) == 1:

   206

                    extern_variables_declarations += [

   207

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

   208

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

   209

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

   210

   211

        # TODO : filter only requiered external declarations

   212

        for v in varlist :

   213

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

   214

                extern_variables_declarations += [

   215

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

   216

   217

        # TODO check if programs need to be declared separately

   218

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

   219

        #                                     p for p in self._ProgramList]),

   220

   221

        # C code to observe/access HMI tree variables

   222

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

   223

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   224

        svghmi_c_code = svghmi_c_file.read()

   225

        svghmi_c_file.close()

   226

        svghmi_c_code = svghmi_c_code % { 

   227

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

   228

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

   229

            "buffer_size": buf_index,

   230

            "item_count": item_count,

   231

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

   232

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

   233

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

   234

            }

   235

   236

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

   237

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   238

        gen_svghmi_c.write(svghmi_c_code)

   239

        gen_svghmi_c.close()

   240

   241

        # Python based WebSocket HMITree Server

   242

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

   243

        svghmiservercode = svghmiserverfile.read()

   244

        svghmiserverfile.close()

   245

   246

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

   247

        runtimefile = open(runtimefile_path, 'w')

   248

        runtimefile.write(svghmiservercode)

   249

        runtimefile.close()

   250

   251

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

   252

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

   253

   254

class SVGHMI(object):

   255

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

   256

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

   257

      <xsd:element name="SVGHMI">

   258

        <xsd:complexType>

   259

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

   260

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

   261

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

   262

        </xsd:complexType>

   263

      </xsd:element>

   264

    </xsd:schema>

   265

    """

   266

    # TODO : add comma separated supported language list

   267

   268

    ConfNodeMethods = [

   269

        {

   270

            "bitmap":    "ImportSVG",

   271

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

   272

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

   273

            "method":   "_ImportSVG"

   274

        },

   275

        {

   276

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

   277

            "name":    _("Inkscape"),

   278

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

   279

            "method":   "_StartInkscape"

   280

        },

   281

   282

        # TODO : Launch POEdit button

   283

        #        PO -> SVG layers button

   284

        #        SVG layers -> PO

   285

   286

        # TODO : HMITree button

   287

        #        - can drag'n'drop variabes to Inkscape

   288

   289

    ]

   290

   291

    def _getSVGpath(self, project_path=None):

   292

        if project_path is None:

   293

            project_path = self.CTNPath()

   294

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

   295

   296

   297

    def OnCTNSave(self, from_project_path=None):

   298

        if from_project_path is not None:

   299

            shutil.copyfile(self._getSVGpath(from_project_path),

   300

                            self._getSVGpath())

   301

        return True

   302

   303

    def GetSVGGeometry(self):

   304

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

   305

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

   306

   307

        inkpath = get_inkscape_path()

   308

        svgpath = self._getSVGpath()

   309

        _status, result, _err_result = ProcessLogger(None,

   310

                                                     inkpath + " -S " + svgpath,

   311

                                                     no_stdout=True,

   312

                                                     no_stderr=True).spin()

   313

        res = []

   314

        for line in result.split():

   315

            strippedline = line.strip()

   316

            attrs = dict(

   317

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

   318

   319

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

   320

   321

        return res

   322

   323

    def GetHMITree(self):

   324

        global hmi_tree_root

   325

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

   326

        return res

   327

   328

    def CTNGenerate_C(self, buildpath, locations):

   329

        """

   330

        Return C code generated by iec2c compiler

   331

        when _generate_softPLC have been called

   332

        @param locations: ignored

   333

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

   334

        """

   335

   336

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

   337

        view_name = self.BaseParams.getName()

   338

   339

        svgfile = self._getSVGpath()

   340

   341

        res = ([], "", False)

   342

   344

   345

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

   347

   348

        if os.path.exists(svgfile):

   349

   350

            # TODO : move to __init__

   351

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

   352

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

   353

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

   354

   355

   356

            # load svg as a DOM with Etree

   357

            svgdom = etree.parse(svgfile)

   358

   359

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

   360

            result = transform.transform(svgdom)

   361

   362

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

   363

            # print(str(result))

   364

            # print(transform.xslt.error_log)

   365

   366

            # TODO

   367

            #   - Errors on HMI semantics

   368

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

   369

   370

        else:

   371

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

   372

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

   373

<html>

   374

<body>

   375

<h1> No SVG file provided </h1>

   376

</body>

   377

</html>

   378

""")

   379

   380

        target_file.close()

   381

   382

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

   383

   384

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

   385

        runtimefile = open(runtimefile_path, 'w')

   386

        runtimefile.write("""

   387

def _runtime_svghmi1_%(location)s_start():

   389

   390

def _runtime_svghmi1_%(location)s_stop():

   391

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

   392

   393

        """ % {"location": location_str,

   394

               "xhtml": target_fname,

   395

               "view_name": view_name})

   396

   397

        runtimefile.close()

   398

   399

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

   400

   401

        return res

   402

   403

    def _ImportSVG(self):

   404

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

   405

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

   406

            svgpath = dialog.GetPath()

   407

            if os.path.isfile(svgpath):

   408

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

   409

            else:

   410

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

   411

        dialog.Destroy()

   412

   413

    def _StartInkscape(self):

   414

        svgfile = self._getSVGpath()

   415

        open_inkscape = True

   416

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

   417

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

   418

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

   419

                                      _("Open Inkscape"),

   420

                                      wx.YES_NO | wx.ICON_QUESTION)

   421

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

   422

            dialog.Destroy()

   423

        if open_inkscape:

   424

            if not os.path.isfile(svgfile):

   425

                svgfile = None

   426

            open_svg(svgfile)