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

    81

    82

        attribs = dict(name=self.name)

    83

        if self.path is not None:

    88

    89

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

    90

    91

        if hasattr(self, "children"): 

    92

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

    93

                res.append(child_etree)

    94

    95

        return res

    96

    97

    def traverse(self):

    98

        yield self

    99

        if hasattr(self, "children"): 

   100

            for c in self.children:

   101

                for yoodl in c.traverse():

   102

                    yield yoodl

   103

   118

# module scope for HMITree root

   119

# so that CTN can use HMITree deduced in Library

   120

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

   121

#       systematicaly invoked before CTN's CTNGenerate_C

   122

   123

hmi_tree_root = None

   124

   125

class SVGHMILibrary(POULibrary):

   126

    def GetLibraryPath(self):

   127

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

   128

   129

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

   131

   132

        """

   133

        PLC Instance Tree:

   134

          prog0

   135

           +->v1 HMI_INT

   136

           +->v2 HMI_INT

   137

           +->fb0 (type mhoo)

   138

           |   +->va HMI_LABEL

   139

           |   +->v3 HMI_INT

   140

           |   +->v4 HMI_INT

   141

           |

   142

           +->fb1 (type mhoo)

   143

           |   +->va HMI_LABEL

   144

           |   +->v3 HMI_INT

   145

           |   +->v4 HMI_INT

   146

           |

   147

           +->fb2

   148

               +->v5 HMI_IN

   149

   150

        HMI tree:

   151

          hmi0

   152

           +->v1

   153

           +->v2

   154

           +->fb0_va

   155

           |   +-> v3

   156

           |   +-> v4

   157

           |

   158

           +->fb1_va

   159

           |   +-> v3

   160

           |   +-> v4

   161

           |

   162

           +->v5

   163

   164

        """

   165

   166

        # Filter known HMI types

   167

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

   168

   169

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

   170

   171

        # add special nodes 

   172

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

   173

                ("plc_status", "HMI_PLC_STATUS"),

   174

                ("current_page", "HMI_CURRENT_PAGE")])

   175

   176

        # deduce HMI tree from PLC HMI_* instances

   177

        for v in hmi_types_instances:

   178

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

   179

            # ignores variables starting with _TMP_

   180

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

   181

                continue

   182

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

   183

            hmi_tree_root.place_node(new_node)

   184

   185

        variable_decl_array = []

   186

        extern_variables_declarations = []

   187

        buf_index = 0

   188

        item_count = 0

   189

        for node in hmi_tree_root.traverse():

   192

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

   193

                variable_decl_array += [

   194

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

   195

                        "EXT": "_P_ENUM",

   196

                        "IN":  "_P_ENUM",

   197

                        "MEM": "_O_ENUM",

   198

                        "OUT": "_O_ENUM",

   199

                        "VAR": "_ENUM"

   200

                    }[node.vartype] + ", " +

   201

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

   202

                buf_index += sz

   203

                item_count += 1

   204

                if len(node.path) == 1:

   205

                    extern_variables_declarations += [

   206

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

   207

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

   208

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

   209

   210

        # TODO : filter only requiered external declarations

   211

        for v in varlist :

   212

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

   213

                extern_variables_declarations += [

   214

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

   215

   216

        # TODO check if programs need to be declared separately

   217

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

   218

        #                                     p for p in self._ProgramList]),

   219

   220

        # C code to observe/access HMI tree variables

   221

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

   222

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   223

        svghmi_c_code = svghmi_c_file.read()

   224

        svghmi_c_file.close()

   225

        svghmi_c_code = svghmi_c_code % { 

   226

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

   227

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

   228

            "buffer_size": buf_index,

   229

            "item_count": item_count,

   230

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

   233

            }

   234

   235

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

   236

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   237

        gen_svghmi_c.write(svghmi_c_code)

   238

        gen_svghmi_c.close()

   239

   240

        # Python based WebSocket HMITree Server

   241

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

   242

        svghmiservercode = svghmiserverfile.read()

   243

        svghmiserverfile.close()

   244

   245

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

   246

        runtimefile = open(runtimefile_path, 'w')

   247

        runtimefile.write(svghmiservercode)

   248

        runtimefile.close()

   249

   250

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

   251

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

   252

   253

class SVGHMI(object):

   254

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

   255

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

   256

      <xsd:element name="SVGHMI">

   257

        <xsd:complexType>

   258

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

   259

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

   260

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

   261

        </xsd:complexType>

   262

      </xsd:element>

   263

    </xsd:schema>

   264

    """

   266

   267

    ConfNodeMethods = [

   268

        {

   269

            "bitmap":    "ImportSVG",

   270

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

   271

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

   272

            "method":   "_ImportSVG"

   273

        },

   274

        {

   275

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

   276

            "name":    _("Inkscape"),

   277

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

   278

            "method":   "_StartInkscape"

   279

        },

   280

   285

        # TODO : HMITree button

   286

        #        - can drag'n'drop variabes to Inkscape

   287

   288

    ]

   289

   290

    def _getSVGpath(self, project_path=None):

   291

        if project_path is None:

   292

            project_path = self.CTNPath()

   293

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

   294

   295

   296

    def OnCTNSave(self, from_project_path=None):

   297

        if from_project_path is not None:

   298

            shutil.copyfile(self._getSVGpath(from_project_path),

   299

                            self._getSVGpath())

   300

        return True

   301

   302

    def GetSVGGeometry(self):

   303

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

   304

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

   305

   306

        inkpath = get_inkscape_path()

   307

        svgpath = self._getSVGpath()

   308

        _status, result, _err_result = ProcessLogger(None,

   309

                                                     inkpath + " -S " + svgpath,

   310

                                                     no_stdout=True,

   311

                                                     no_stderr=True).spin()

   312

        res = []

   313

        for line in result.split():

   314

            strippedline = line.strip()

   315

            attrs = dict(

   316

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

   317

   318

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

   319

   320

        return res

   321

   322

    def GetHMITree(self):

   323

        global hmi_tree_root

   325

        return res

   326

   327

    def CTNGenerate_C(self, buildpath, locations):

   328

        """

   329

        Return C code generated by iec2c compiler

   330

        when _generate_softPLC have been called

   331

        @param locations: ignored

   332

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

   333

        """

   334

   335

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

   336

        view_name = self.BaseParams.getName()

   337

   338

        svgfile = self._getSVGpath()

   339

   340

        res = ([], "", False)

   341

   342

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

   343

   344

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

   345

        target_file = open(target_path, 'w')

   346

   347

        if os.path.exists(svgfile):

   348

   349

            # TODO : move to __init__

   350

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

   351

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

   352

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

   353

   354

   355

            # load svg as a DOM with Etree

   356

            svgdom = etree.parse(svgfile)

   357

   358

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

   359

            result = transform.transform(svgdom)

   360

   361

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

   362

            # print(str(result))

   363

            # print(transform.xslt.error_log)

   364

   365

            # TODO

   366

            #   - Errors on HMI semantics

   367

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

   368

   369

        else:

   370

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

   371

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

   372

<html>

   373

<body>

   374

<h1> No SVG file provided </h1>

   375

</body>

   376

</html>

   377

""")

   378

   379

        target_file.close()

   380

   381

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

   382

   383

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

   384

        runtimefile = open(runtimefile_path, 'w')

   385

        runtimefile.write("""

   386

def _runtime_svghmi1_%(location)s_start():

   387

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

   388

   389

def _runtime_svghmi1_%(location)s_stop():

   390

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

   391

   392

        """ % {"location": location_str,

   393

               "xhtml": target_fname,

   394

               "view_name": view_name})

   395

   396

        runtimefile.close()

   397

   398

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

   399

   400

        return res

   401

   402

    def _ImportSVG(self):

   403

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

   404

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

   405

            svgpath = dialog.GetPath()

   406

            if os.path.isfile(svgpath):

   407

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

   408

            else:

   409

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

   410

        dialog.Destroy()

   411

   412

    def _StartInkscape(self):

   413

        svgfile = self._getSVGpath()

   414

        open_inkscape = True

   415

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

   416

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

   417

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

   418

                                      _("Open Inkscape"),

   419

                                      wx.YES_NO | wx.ICON_QUESTION)

   420

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

   421

            dialog.Destroy()

   422

        if open_inkscape:

   423

            if not os.path.isfile(svgfile):

   424

                svgfile = None

   425

            open_svg(svgfile)