1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz

     5

# Copyright (C) 2021: Edouard TISSERANT

     6

#

     7

# See COPYING file for copyrights details.

     8

     9

from __future__ import absolute_import

    10

import os

    11

import shutil

    12

import hashlib

    13

import shlex

    14

import time

    15

    16

import wx

    17

    18

from lxml import etree

    19

from lxml.etree import XSLTApplyError

    20

    21

import util.paths as paths

    22

from POULibrary import POULibrary

    23

from docutil import open_svg, get_inkscape_path

    24

    25

from util.ProcessLogger import ProcessLogger

    26

from runtime.typemapping import DebugTypesSize

    27

import targets

    28

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    29

from XSLTransform import XSLTransform

    30

from svghmi.i18n import EtreeToMessages, SaveCatalog, ReadTranslations,\

    31

                        MatchTranslations, TranslationToEtree, open_pofile

    32

from svghmi.hmi_tree import HMI_TYPES, HMITreeNode, SPECIAL_NODES 

    33

from svghmi.ui import SVGHMI_UI

    35

    36

    37

ScriptDirectory = paths.AbsDir(__file__)

    38

    39

    40

# module scope for HMITree root

    41

# so that CTN can use HMITree deduced in Library

    42

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

    43

#       systematicaly invoked before CTN's CTNGenerate_C

    44

    45

hmi_tree_root = None

    46

    47

on_hmitree_update = None

    48

    49

class SVGHMILibrary(POULibrary):

    50

    def GetLibraryPath(self):

    51

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

    52

    53

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

    54

        global hmi_tree_root, on_hmitree_update

    55

    56

        """

    57

        PLC Instance Tree:

    58

          prog0

    59

           +->v1 HMI_INT

    60

           +->v2 HMI_INT

    61

           +->fb0 (type mhoo)

    62

           |   +->va HMI_NODE

    63

           |   +->v3 HMI_INT

    64

           |   +->v4 HMI_INT

    65

           |

    66

           +->fb1 (type mhoo)

    67

           |   +->va HMI_NODE

    68

           |   +->v3 HMI_INT

    69

           |   +->v4 HMI_INT

    70

           |

    71

           +->fb2

    72

               +->v5 HMI_IN

    73

    74

        HMI tree:

    75

          hmi0

    76

           +->v1

    77

           +->v2

    78

           +->fb0 class:va

    79

           |   +-> v3

    80

           |   +-> v4

    81

           |

    82

           +->fb1 class:va

    83

           |   +-> v3

    84

           |   +-> v4

    85

           |

    86

           +->v5

    87

    88

        """

    89

    90

        # Filter known HMI types

    91

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

    92

    93

        hmi_tree_root = None

    94

    95

        # take first HMI_NODE (placed as special node), make it root

    96

        for i,v in enumerate(hmi_types_instances):

    97

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

    98

            derived = v["derived"]

    99

            if derived == "HMI_NODE":

   100

                hmi_tree_root = HMITreeNode(path, "", derived, v["type"], v["vartype"], v["C_path"])

   101

                hmi_types_instances.pop(i)

   102

                break

   103

   104

        if hmi_tree_root is None:

   105

            self.FatalError("SVGHMI : Library is selected but not used. Please either deselect it in project config or add a SVGHMI node to project.")

   106

   107

        # deduce HMI tree from PLC HMI_* instances

   108

        for v in hmi_types_instances:

   109

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

   110

            # ignores variables starting with _TMP_

   111

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

   112

                continue

   113

            derived = v["derived"]

   114

            kwargs={}

   115

            if derived == "HMI_NODE":

   116

                # TODO : make problem if HMI_NODE used in CONFIG or RESOURCE

   117

                name = path[-2]

   118

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

   119

            else:

   120

                name = path[-1]

   121

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

   122

            placement_result = hmi_tree_root.place_node(new_node)

   123

            if placement_result is not None:

   124

                cause, problematic_node = placement_result

   125

                if cause == "Non_Unique":

   126

                    message = _("HMI tree nodes paths are not unique.\nConflicting variable: {} {}").format(

   127

                        ".".join(problematic_node.path),

   128

                        ".".join(new_node.path))

   129

   130

                    last_FB = None 

   131

                    for v in varlist:

   132

                        if v["vartype"] == "FB":

   133

                            last_FB = v 

   134

                        if v["C_path"] == problematic_node:

   135

                            break

   136

                    if last_FB is not None:

   137

                        failing_parent = last_FB["type"]

   138

                        message += "\n"

   139

                        message += _("Solution: Add HMI_NODE at beginning of {}").format(failing_parent)

   140

   141

                elif cause in ["Late_HMI_NODE", "Duplicate_HMI_NODE"]:

   142

                    cause, problematic_node = placement_result

   143

                    message = _("There must be only one occurrence of HMI_NODE before any HMI_* variable in POU.\nConflicting variable: {} {}").format(

   144

                        ".".join(problematic_node.path),

   145

                        ".".join(new_node.path))

   146

   147

                self.FatalError("SVGHMI : " + message)

   148

   149

        if on_hmitree_update is not None:

   150

            on_hmitree_update(hmi_tree_root)

   151

   152

        variable_decl_array = []

   153

        extern_variables_declarations = []

   154

        buf_index = 0

   155

        item_count = 0

   156

        found_heartbeat = False

   157

   158

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   159

   160

        for node in hmi_tree_root.traverse():

   161

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   162

                hmi_tree_hearbeat_index = item_count

   163

                found_heartbeat = True

   164

                extern_variables_declarations += [

   165

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   166

                ]

   167

            if hasattr(node, "iectype"):

   168

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

   169

                variable_decl_array += [

   170

                    "{&(" + node.cpath + "), " + node.iectype + {

   171

                        "EXT": "_P_ENUM",

   172

                        "IN":  "_P_ENUM",

   173

                        "MEM": "_O_ENUM",

   174

                        "OUT": "_O_ENUM",

   175

                        "VAR": "_ENUM"

   176

                    }[node.vartype] + ", " +

   177

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

   178

                buf_index += sz

   179

                item_count += 1

   180

                if len(node.path) == 1:

   181

                    extern_variables_declarations += [

   182

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

   183

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

   184

                        + node.cpath + ";"]

   185

   186

        assert(found_heartbeat)

   187

   188

        # TODO : filter only requiered external declarations

   189

        for v in varlist:

   190

            if v["C_path"].find('.') < 0:

   191

                extern_variables_declarations += [

   192

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

   193

   194

        # TODO check if programs need to be declared separately

   195

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

   196

        #                                     p for p in self._ProgramList]),

   197

   198

        # C code to observe/access HMI tree variables

   199

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

   200

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   201

        svghmi_c_code = svghmi_c_file.read()

   202

        svghmi_c_file.close()

   203

        svghmi_c_code = svghmi_c_code % {

   204

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

   205

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

   206

            "buffer_size": buf_index,

   207

            "item_count": item_count,

   208

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

   209

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

   210

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

   211

            }

   212

   213

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

   214

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   215

        gen_svghmi_c.write(svghmi_c_code)

   216

        gen_svghmi_c.close()

   217

   218

        # Python based WebSocket HMITree Server

   219

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

   220

        svghmiservercode = svghmiserverfile.read()

   221

        svghmiserverfile.close()

   222

   223

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

   224

        runtimefile = open(runtimefile_path, 'w')

   225

        runtimefile.write(svghmiservercode)

   226

        runtimefile.close()

   227

   228

        # Backup HMI Tree in XML form so that it can be loaded without building

   229

        hmitree_backup_path = os.path.join(buildpath, "hmitree.xml")

   230

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   231

        hmitree_backup_file.write(etree.tostring(hmi_tree_root.etree()))

   232

        hmitree_backup_file.close()

   233

   234

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

   235

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

   236

                #         ^

   237

                # note the double zero after "runtime_", 

   238

                # to ensure placement before other CTN generated code in execution order

   239

   240

   241

def Register_SVGHMI_UI_for_HMI_tree_updates(ref):

   242

    global on_hmitree_update

   243

    def HMITreeUpdate(_hmi_tree_root):

   244

        obj = ref()

   245

        if obj is not None:

   246

            obj.HMITreeUpdate(_hmi_tree_root)

   247

   248

    on_hmitree_update = HMITreeUpdate

   249

   250

   251

class SVGHMIEditor(ConfTreeNodeEditor):

   252

    CONFNODEEDITOR_TABS = [

   253

        (_("HMI Tree"), "CreateSVGHMI_UI")]

   254

   255

    def CreateSVGHMI_UI(self, parent):

   256

        global hmi_tree_root

   257

   258

        if hmi_tree_root is None:

   259

            buildpath = self.Controler.GetCTRoot()._getBuildPath()

   260

            hmitree_backup_path = os.path.join(buildpath, "hmitree.xml")

   261

            if os.path.exists(hmitree_backup_path):

   262

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   263

                hmi_tree_root = HMITreeNode.from_etree(etree.parse(hmitree_backup_file).getroot())

   264

   265

        ret = SVGHMI_UI(parent, Register_SVGHMI_UI_for_HMI_tree_updates)

   266

   267

        on_hmitree_update(hmi_tree_root)

   268

   269

        return ret

   270

   271

class SVGHMI(object):

   272

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

   273

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

   274

      <xsd:element name="SVGHMI">

   275

        <xsd:complexType>

   276

          <xsd:attribute name="OnStart" type="xsd:string" use="optional"/>

   277

          <xsd:attribute name="OnStop" type="xsd:string" use="optional"/>

   278

          <xsd:attribute name="OnWatchdog" type="xsd:string" use="optional"/>

   279

          <xsd:attribute name="WatchdogInitial" type="xsd:integer" use="optional"/>

   280

          <xsd:attribute name="WatchdogInterval" type="xsd:integer" use="optional"/>

   281

        </xsd:complexType>

   282

      </xsd:element>

   283

    </xsd:schema>

   284

    """

   285

   286

    EditorType = SVGHMIEditor

   287

   288

    ConfNodeMethods = [

   289

        {

   290

            "bitmap":    "ImportSVG",

   291

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

   292

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

   293

            "method":   "_ImportSVG"

   294

        },

   295

        {

   297

            "name":    _("Inkscape"),

   298

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

   299

            "method":   "_StartInkscape"

   300

        },

   301

        {

   303

            "name":    _("New lang"),

   304

            "tooltip": _("Open non translated message catalog (POT) to start new language"),

   305

            "method":   "_OpenPOT"

   306

        },

   307

        {

   309

            "name":    _("Edit lang"),

   310

            "tooltip": _("Edit existing message catalog (PO) for specific language"),

   311

            "method":   "_EditPO"

   312

        },

   325

    ]

   326

   327

    def _getSVGpath(self, project_path=None):

   328

        if project_path is None:

   329

            project_path = self.CTNPath()

   330

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

   331

   332

    def _getPOTpath(self, project_path=None):

   333

        if project_path is None:

   334

            project_path = self.CTNPath()

   335

        return os.path.join(project_path, "messages.pot")

   336

   337

    def OnCTNSave(self, from_project_path=None):

   338

        if from_project_path is not None:

   339

            shutil.copyfile(self._getSVGpath(from_project_path),

   340

                            self._getSVGpath())

   341

            shutil.copyfile(self._getPOTpath(from_project_path),

   342

                            self._getPOTpath())

   343

            # XXX TODO copy .PO files

   344

        return True

   345

   346

    def GetSVGGeometry(self):

   347

        self.ProgressStart("inkscape", "collecting SVG geometry (Inkscape)")

   348

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

   349

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

   350

   351

        inkpath = get_inkscape_path()

   352

   353

        if inkpath is None:

   354

            self.FatalError("SVGHMI: inkscape is not installed.")

   355

   356

        svgpath = self._getSVGpath()

   357

        status, result, _err_result = ProcessLogger(self.GetCTRoot().logger,

   358

                                                     '"' + inkpath + '" -S "' + svgpath + '"',

   359

                                                     no_stdout=True,

   360

                                                     no_stderr=True).spin()

   361

        if status != 0:

   362

            self.FatalError("SVGHMI: inkscape couldn't extract geometry from given SVG.")

   363

   364

        res = []

   365

        for line in result.split():

   366

            strippedline = line.strip()

   367

            attrs = dict(

   368

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

   369

   370

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

   371

   372

        self.ProgressEnd("inkscape")

   373

        return res

   374

   375

    def GetHMITree(self):

   376

        global hmi_tree_root

   377

        self.ProgressStart("hmitree", "getting HMI tree")

   378

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

   379

        self.ProgressEnd("hmitree")

   380

        return res

   381

   382

    def GetTranslations(self, _context, msgs):

   383

        self.ProgressStart("i18n", "getting Translations")

   384

        messages = EtreeToMessages(msgs)

   385

   386

        if len(messages) == 0:

   387

            self.ProgressEnd("i18n")

   388

            return

   389

   390

        SaveCatalog(self._getPOTpath(), messages)

   391

   392

        translations = ReadTranslations(self.CTNPath())

   393

   394

        langs,translated_messages = MatchTranslations(translations, messages, 

   395

            errcallback=self.GetCTRoot().logger.write_warning)

   396

   397

        ret = TranslationToEtree(langs,translated_messages)

   398

   399

        self.ProgressEnd("i18n")

   400

   401

        return ret

   402

   403

    times_msgs = {}

   404

    indent = 1

   405

    def ProgressStart(self, k, m):

   406

        self.times_msgs[k] = (time.time(), m)

   407

        self.GetCTRoot().logger.write("    "*self.indent + "Start %s...\n"%m)

   408

        self.indent = self.indent + 1

   409

   410

    def ProgressEnd(self, k):

   411

        t = time.time()

   412

        oldt, m = self.times_msgs[k]

   413

        self.indent = self.indent - 1

   414

        self.GetCTRoot().logger.write("    "*self.indent + "... finished in %.3fs\n"%(t - oldt))

   415

   416

    def CTNGenerate_C(self, buildpath, locations):

   417

   418

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

   419

        view_name = self.BaseParams.getName()

   420

   421

        svgfile = self._getSVGpath()

   422

   423

        res = ([], "", False)

   424

   425

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

   426

   427

        build_path = self._getBuildPath()

   428

        target_path = os.path.join(build_path, target_fname)

   429

        hash_path = os.path.join(build_path, "svghmi.md5")

   430

   431

        self.GetCTRoot().logger.write("SVGHMI:\n")

   432

   433

        if os.path.exists(svgfile):

   434

   435

            hasher = hashlib.md5()

   436

            hmi_tree_root._hash(hasher)

   437

            with open(svgfile, 'rb') as afile:

   438

                while True:

   439

                    buf = afile.read(65536)

   440

                    if len(buf) > 0:

   441

                        hasher.update(buf)

   442

                    else:

   443

                        break

   444

            digest = hasher.hexdigest()

   445

   446

            if os.path.exists(hash_path):

   447

                with open(hash_path, 'rb') as digest_file:

   448

                    last_digest = digest_file.read()

   449

            else:

   450

                last_digest = None

   451

   452

            if digest != last_digest:

   453

   454

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

   455

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

   456

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

   457

                               ("GetTranslations", self.GetTranslations),

   458

                               ("ProgressStart", lambda _ign,k,m:self.ProgressStart(str(k),str(m))),

   459

                               ("ProgressEnd", lambda _ign,k:self.ProgressEnd(str(k)))])

   460

   461

                self.ProgressStart("svg", "source SVG parsing")

   462

   463

                # load svg as a DOM with Etree

   464

                svgdom = etree.parse(svgfile)

   465

   466

                self.ProgressEnd("svg")

   467

   468

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

   469

                try: 

   470

                    self.ProgressStart("xslt", "XSLT transform")

   471

                    result = transform.transform(svgdom)  # , profile_run=True)

   472

                    self.ProgressEnd("xslt")

   473

                except XSLTApplyError as e:

   474

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

   475

                finally:

   476

                    for entry in transform.get_error_log():

   477

                        message = "SVGHMI: "+ entry.message + "\n" 

   478

                        self.GetCTRoot().logger.write_warning(message)

   479

   480

                target_file = open(target_path, 'wb')

   481

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

   482

                target_file.close()

   483

   484

                # print(str(result))

   485

                # print(transform.xslt.error_log)

   486

                # print(etree.tostring(result.xslt_profile,pretty_print=True))

   487

   488

                with open(hash_path, 'wb') as digest_file:

   489