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

        variable_decl_array = []

   169

        extern_variables_declarations = []

   170

        buf_index = 0

   171

        item_count = 0

   172

        for node in hmi_tree_root.traverse():

   173

            if hasattr(node, "iectype"):

   174

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

   175

                variable_decl_array += [

   176

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

   177

                        "EXT": "_P_ENUM",

   178

                        "IN":  "_P_ENUM",

   179

                        "MEM": "_O_ENUM",

   180

                        "OUT": "_O_ENUM",

   181

                        "VAR": "_ENUM"

   182

                    }[node.vartype] + ", " +

   183

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

   184

                buf_index += sz

   185

                item_count += 1

   186

                if len(node.path) == 1:

   187

                    extern_variables_declarations += [

   188

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

   189

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

   190

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

   191

   192

        # TODO : filter only requiered external declarations

   193

        for v in varlist :

   194

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

   195

                extern_variables_declarations += [

   196

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

   197

   198

        # TODO check if programs need to be declared separately

   199

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

   200

        #                                     p for p in self._ProgramList]),

   201

   202

        # C code to observe/access HMI tree variables

   203

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

   204

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   205

        svghmi_c_code = svghmi_c_file.read()

   206

        svghmi_c_file.close()

   207

        svghmi_c_code = svghmi_c_code % { 

   208

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

   209

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

   210

            "buffer_size": buf_index,

   211

            "item_count": item_count,

   212

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

   213

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

   214

            }

   215

   216

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

   217

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   218

        gen_svghmi_c.write(svghmi_c_code)

   219

        gen_svghmi_c.close()

   220

   221

        # Python based WebSocket HMITree Server

   222

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

   223

        svghmiservercode = svghmiserverfile.read()

   224

        svghmiserverfile.close()

   225

   226

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

   227

        runtimefile = open(runtimefile_path, 'w')

   228

        runtimefile.write(svghmiservercode)

   229

        runtimefile.close()

   230

   231

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

   232

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

   233

   234

class SVGHMI(object):

   235

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

   236

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

   237

      <xsd:element name="SVGHMI">

   238

        <xsd:complexType>

   239

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

   240

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

   241

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

   242

        </xsd:complexType>

   243

      </xsd:element>

   244

    </xsd:schema>

   245

    """

   246

   247

    ConfNodeMethods = [

   248

        {

   249

            "bitmap":    "ImportSVG",

   250

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

   251

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

   252

            "method":   "_ImportSVG"

   253

        },

   254

        {

   255

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

   256

            "name":    _("Inkscape"),

   257

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

   258

            "method":   "_StartInkscape"

   259

        },

   260

   261

        # TODO : HMITree button

   262

        #        - can drag'n'drop variabes to Inkscape

   263

   264

    ]

   265

   266

    def _getSVGpath(self, project_path=None):

   267

        if project_path is None:

   268

            project_path = self.CTNPath()

   269

        # define name for SVG file containing gui layout

   270

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

   271

   272

   273

    def OnCTNSave(self, from_project_path=None):

   274

        if from_project_path is not None:

   275

            shutil.copyfile(self._getSVGpath(from_project_path),

   276

                            self._getSVGpath())

   277

        return True

   278

   279

    def GetSVGGeometry(self):

   280

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

   281

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

   282

   283

        # TODO : move following line to __init__

   284

        inkpath = get_inkscape_path()

   285

        svgpath = self._getSVGpath()

   286

        _status, result, _err_result = ProcessLogger(None,

   287

                                                     inkpath + " -S " + svgpath,

   288

                                                     no_stdout=True,

   289

                                                     no_stderr=True).spin()

   290

        res = []

   291

        for line in result.split():

   292

            strippedline = line.strip()

   293

            attrs = dict(

   294

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

   295

   296

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

   297

   298

        return res

   299

   300

    def GetHMITree(self):

   301

        global hmi_tree_root

   302

        res = [hmi_tree_root.etree()]

   303

        return res

   304

   305

    def CTNGenerate_C(self, buildpath, locations):

   306

        """

   307

        Return C code generated by iec2c compiler

   308

        when _generate_softPLC have been called

   309

        @param locations: ignored

   310

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

   311

        """

   312

   313

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

   314

        view_name = self.BaseParams.getName()

   315

   316

        svgfile = self._getSVGpath()

   317

   318

        res = ([], "", False)

   319

   320

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

   321

   322

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

   323

        target_file = open(target_path, 'w')

   324

   325

        if os.path.exists(svgfile):

   326

   327

            # TODO : move to __init__

   328

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

   329

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

   330

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

   331

   332

   333

            # load svg as a DOM with Etree

   334

            svgdom = etree.parse(svgfile)

   335

   336

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

   337

            result = transform.transform(svgdom)

   338

   339

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

   340

            # print(str(result))

   341

            # print(transform.xslt.error_log)

   342

   343

            # TODO

   344

            #   - Errors on HMI semantics

   345

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

   346

   347

        else:

   348

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

   349

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

   350

<html>

   351

<body>

   352

<h1> No SVG file provided </h1>

   353

</body>

   354

</html>

   355

""")

   356

   357

        target_file.close()

   358

   359

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

   360

   361

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

   362

        runtimefile = open(runtimefile_path, 'w')

   363

        runtimefile.write("""

   364

def _runtime_svghmi1_%(location)s_start():

   365

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

   366

   370

        """ % {"location": location_str,

   371

               "xhtml": target_fname,

   372

               "view_name": view_name})

   373

   374

        runtimefile.close()

   375

   376

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

   377

   378

        return res

   379

   380

    def _ImportSVG(self):

   381

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

   382

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

   383

            svgpath = dialog.GetPath()

   384

            if os.path.isfile(svgpath):

   385

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

   386

            else:

   387

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

   388

        dialog.Destroy()

   389

   390

    def _StartInkscape(self):

   391

        svgfile = self._getSVGpath()

   392

        open_inkscape = True

   393

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

   394

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

   395

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

   396

                                      _("Open Inkscape"),

   397

                                      wx.YES_NO | wx.ICON_QUESTION)

   398

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

   399

            dialog.Destroy()

   400

        if open_inkscape:

   401

            if not os.path.isfile(svgfile):

   402

                svgfile = None

   403

            open_svg(svgfile)