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

    15

import wx

    16

    17

import util.paths as paths

    18

from POULibrary import POULibrary

    19

from docutil import open_svg, get_inkscape_path

    20

from lxml import etree

    21

    22

from util.ProcessLogger import ProcessLogger

    23

from runtime.typemapping import DebugTypesSize

    24

import targets

    25

    26

HMI_TYPES_DESC = {

    27

    "HMI_CLASS":{},

    28

    "HMI_LABEL":{},

    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

    38

ScriptDirectory = paths.AbsDir(__file__)

    39

    40

class HMITreeNode(object):

    41

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

    42

        self.path = path

    43

        self.name = name

    44

        self.nodetype = nodetype

    45

    46

        if iectype is not None:

    47

            self.iectype = iectype

    48

            self.vartype = vartype

    49

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

    50

            self.children = []

    51

    52

    def pprint(self, indent = 0):

    53

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

    54

        if hasattr(self, "children"): 

    55

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

    56

                              for child in self.children])

    57

            res += "\n"

    58

    59

        return res

    60

    61

    def place_node(self, node):

    62

        best_child = None

    63

        known_best_match = 0

    64

        for child in self.children : 

    65

            if child.path is not None:

    66

                in_common = 0

    67

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

    68

                    if child_path_item == node_path_item:

    69

                        in_common +=1

    70

                    else:

    71

                        break

    72

                if in_common > known_best_match:

    73

                    known_best_match = in_common

    74

                    best_child = child

    75

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

    76

            best_child.place_node(node)

    77

        else:

    78

            self.children.append(node)

    79

    80

    def etree(self):

    81

    82

        attribs = dict(name=self.name)

    83

        if self.path is not None:

    84

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

    85

    86

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

    87

    88

        if hasattr(self, "children"): 

    89

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

    90

                res.append(child_etree)

    91

    92

        return res

    93

    94

    def traverse(self):

    95

        yield self

    96

        if hasattr(self, "children"): 

    97

            for c in self.children:

    98

                for yoodl in c.traverse():

    99

                    yield yoodl

   100

   101

# module scope for HMITree root

   102

# so that CTN can use HMITree deduced in Library

   103

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

   104

#       systematicaly invoked before CTN's CTNGenerate_C

   105

   106

hmi_tree_root = None

   107

   108

class SVGHMILibrary(POULibrary):

   109

    def GetLibraryPath(self):

   110

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

   111

   112

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

   113

        global hmi_tree_root

   114

   115

        """

   116

        PLC Instance Tree:

   117

          prog0

   118

           +->v1 HMI_INT

   119

           +->v2 HMI_INT

   120

           +->fb0 (type mhoo)

   121

           |   +->va HMI_LABEL

   122

           |   +->v3 HMI_INT

   123

           |   +->v4 HMI_INT

   124

           |

   125

           +->fb1 (type mhoo)

   126

           |   +->va HMI_LABEL

   127

           |   +->v3 HMI_INT

   128

           |   +->v4 HMI_INT

   129

           |

   130

           +->fb2

   131

               +->v5 HMI_IN

   132

   133

        HMI tree:

   134

          hmi0

   135

           +->v1

   136

           +->v2

   137

           +->fb0_va

   138

           |   +-> v3

   139

           |   +-> v4

   140

           |

   141

           +->fb1_va

   142

           |   +-> v3

   143

           |   +-> v4

   144

           |

   145

           +->v5

   146

   147

        """

   148

   149

        # Filter known HMI types

   150

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

   151

   152

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

   153

   154

        # add special nodes 

   155

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

   156

                ("plc_status", "HMI_PLC_STATUS"),

   157

                ("current_page", "HMI_CURRENT_PAGE")])

   158

   159

        # deduce HMI tree from PLC HMI_* instances

   160

        for v in hmi_types_instances:

   161

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

   162

            # ignores variables starting with _TMP_

   163

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

   164

                continue

   165

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

   166

            hmi_tree_root.place_node(new_node)

   167

   168

        print(hmi_tree_root.pprint())

   169

   170

        variable_decl_array = []

   171

        extern_variables_declarations = []

   172

        buf_index = 0

   174

        for node in hmi_tree_root.traverse():

   175

            if hasattr(node, "iectype"):

   176

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

   177

                variable_decl_array += [

   178

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

   179

                        "EXT": "_P_ENUM",

   180

                        "IN":  "_P_ENUM",

   181

                        "MEM": "_O_ENUM",

   182

                        "OUT": "_O_ENUM",

   183

                        "VAR": "_ENUM"

   184

                    }[node.vartype] + ", " +

   185

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

   186

                buf_index += sz

   188

                if len(node.path) == 1:

   189

                    extern_variables_declarations += [

   190

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

   191

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

   192

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

   193

   194

        # TODO : filter only requiered external declarations

   195

        for v in varlist :

   196

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

   197

                extern_variables_declarations += [

   198

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

   199

   200

        # TODO check if programs need to be declared separately

   201

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

   202

        #                                     p for p in self._ProgramList]),

   203

   204

        # C code to observe/access HMI tree variables

   205

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

   206

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   207

        svghmi_c_code = svghmi_c_file.read()

   208

        svghmi_c_file.close()

   209

        svghmi_c_code = svghmi_c_code % { 

   210

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

   211

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

   212

            "buffer_size": buf_index,

   214

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

   215

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

   216

            }

   217

   218

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

   219

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   220

        gen_svghmi_c.write(svghmi_c_code)

   221

        gen_svghmi_c.close()

   222

   223

        # Python based WebSocket HMITree Server

   224

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

   225

        svghmiservercode = svghmiserverfile.read()

   226

        svghmiserverfile.close()

   227

   228

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

   229

        runtimefile = open(runtimefile_path, 'w')

   230

        runtimefile.write(svghmiservercode)

   231

        runtimefile.close()

   232

   233

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

   234

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

   235

   236

class SVGHMI(object):

   237

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

   238

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

   239

      <xsd:element name="SVGHMI">

   240

        <xsd:complexType>

   241

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

   242

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

   243

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

   244

        </xsd:complexType>

   245

      </xsd:element>

   246

    </xsd:schema>

   247

    """

   248

   249

    ConfNodeMethods = [

   250

        {

   251

            "bitmap":    "ImportSVG",

   252

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

   253

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

   254

            "method":   "_ImportSVG"

   255

        },

   256

        {

   257

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

   258

            "name":    _("Inkscape"),

   259

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

   260

            "method":   "_StartInkscape"

   261

        },

   262

   263

        # TODO : HMITree button

   264

        #        - can drag'n'drop variabes to Inkscape

   265

   266

    ]

   267

   268

    def _getSVGpath(self, project_path=None):

   269

        if project_path is None:

   270

            project_path = self.CTNPath()

   271

        # define name for SVG file containing gui layout

   272

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

   273

   274

   275

    def OnCTNSave(self, from_project_path=None):

   276

        if from_project_path is not None:

   277

            shutil.copyfile(self._getSVGpath(from_project_path),

   278

                            self._getSVGpath())

   279

        return True

   280

   281

    def GetSVGGeometry(self):

   282

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

   283

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

   284

   285

        # TODO : move following line to __init__

   286

        inkpath = get_inkscape_path()

   287

        svgpath = self._getSVGpath()

   288

        _status, result, _err_result = ProcessLogger(None,

   289

                                                     inkpath + " -S " + svgpath,

   290

                                                     no_stdout=True,

   291

                                                     no_stderr=True).spin()

   292

        res = []

   293

        for line in result.split():

   294

            strippedline = line.strip()

   295

            attrs = dict(

   296

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

   297

   298

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

   299

   300

        return res

   301

   302

    def GetHMITree(self):

   303

        global hmi_tree_root

   304

        res = [hmi_tree_root.etree()]

   305

        return res

   306

   307

    def CTNGenerate_C(self, buildpath, locations):

   308

        """

   309

        Return C code generated by iec2c compiler

   310

        when _generate_softPLC have been called

   311

        @param locations: ignored

   312

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

   313

        """

   314

   315

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

   316

        view_name = self.BaseParams.getName()

   317

   318

        svgfile = self._getSVGpath()

   319

   320

        res = ([], "", False)

   321

   322

        target_fname = "sghmi_"+location_str+".xhtml"

   323

   324

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

   325

        target_file = open(target_path, 'w')

   326

   327

        if os.path.exists(svgfile):

   328

   329

            # TODO : move to __init__

   330

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

   331

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

   332

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

   333

   334

   335

            # load svg as a DOM with Etree

   336

            svgdom = etree.parse(svgfile)

   337

   338

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

   339

            result = transform.transform(svgdom)

   340

   341

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

   342

            # print(str(result))

   343

            # print(transform.xslt.error_log)

   344

   345

            # TODO

   346

            #   - Errors on HMI semantics

   347

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

   348

   349

        else:

   350

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

   351

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

   352

<html>

   353

<body>

   354

<h1> No SVG file provided </h1>

   355

</body>

   356

</html>

   357

""")

   358

   359

        target_file.close()

   360

   361

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

   362

   363

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

   364

        runtimefile = open(runtimefile_path, 'w')

   365

        runtimefile.write("""

   366

def _runtime_svghmi1_%(location)s_start():

   367

    svghmi_root.putChild('%(view_name)s',File('%(xhtml)s'))

   368

   369

        """ % {"location": location_str,

   370

               "xhtml": target_fname,

   371

               "view_name": view_name})

   372

   373

        runtimefile.close()

   374

   375

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

   376

   377

        return res

   378

   379

    def _ImportSVG(self):

   380

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

   381

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

   382

            svgpath = dialog.GetPath()

   383

            if os.path.isfile(svgpath):

   384

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

   385

            else:

   386

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

   387

        dialog.Destroy()

   388

   389

    def _StartInkscape(self):

   390

        svgfile = self._getSVGpath()

   391

        open_inkscape = True

   392

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

   393

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

   394

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

   395

                                      _("Open Inkscape"),

   396

                                      wx.YES_NO | wx.ICON_QUESTION)

   397

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

   398

            dialog.Destroy()

   399

        if open_inkscape:

   400

            if not os.path.isfile(svgfile):

   401

                svgfile = None

   402

            open_svg(svgfile)