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

                        GetPoFiles

    33

from svghmi.hmi_tree import HMI_TYPES, HMITreeNode, SPECIAL_NODES 

    34

from svghmi.ui import SVGHMI_UI

    35

from svghmi.fonts import GetFontTypeAndFamilyName, GetCSSFontFaceFromFontFile

    36

    37

    38

ScriptDirectory = paths.AbsDir(__file__)

    39

    40

    41

# module scope for HMITree root

    42

# so that CTN can use HMITree deduced in Library

    43

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

    44

#       systematicaly invoked before CTN's CTNGenerate_C

    45

    46

hmi_tree_root = None

    47

    48

on_hmitree_update = None

    49

    50

maxConnectionsTotal = 0

    51

    52

class SVGHMILibrary(POULibrary):

    53

    def GetLibraryPath(self):

    54

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

    55

    56

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

    57

        global hmi_tree_root, on_hmitree_update, maxConnectionsTotal

    58

    59

        """

    60

        PLC Instance Tree:

    61

          prog0

    62

           +->v1 HMI_INT

    63

           +->v2 HMI_INT

    64

           +->fb0 (type mhoo)

    65

           |   +->va HMI_NODE

    66

           |   +->v3 HMI_INT

    67

           |   +->v4 HMI_INT

    68

           |

    69

           +->fb1 (type mhoo)

    70

           |   +->va HMI_NODE

    71

           |   +->v3 HMI_INT

    72

           |   +->v4 HMI_INT

    73

           |

    74

           +->fb2

    75

               +->v5 HMI_IN

    76

    77

        HMI tree:

    78

          hmi0

    79

           +->v1

    80

           +->v2

    81

           +->fb0 class:va

    82

           |   +-> v3

    83

           |   +-> v4

    84

           |

    85

           +->fb1 class:va

    86

           |   +-> v3

    87

           |   +-> v4

    88

           |

    89

           +->v5

    90

    91

        """

    92

    93

        # Filter known HMI types

    94

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

    95

    96

        hmi_tree_root = None

    97

    98

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

    99

        for i,v in enumerate(hmi_types_instances):

   100

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

   101

            derived = v["derived"]

   102

            if derived == "HMI_NODE":

   103

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

   104

                hmi_types_instances.pop(i)

   105

                break

   106

   107

        if hmi_tree_root is None:

   108

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

   109

   110

        # deduce HMI tree from PLC HMI_* instances

   111

        for v in hmi_types_instances:

   112

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

   113

            # ignores variables starting with _TMP_

   114

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

   115

                continue

   116

            derived = v["derived"]

   117

            kwargs={}

   118

            if derived == "HMI_NODE":

   119

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

   120

                name = path[-2]

   121

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

   122

            else:

   123

                name = path[-1]

   124

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

   125

            placement_result = hmi_tree_root.place_node(new_node)

   126

            if placement_result is not None:

   127

                cause, problematic_node = placement_result

   128

                if cause == "Non_Unique":

   129

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

   130

                        ".".join(problematic_node.path),

   131

                        ".".join(new_node.path))

   132

   133

                    last_FB = None 

   134

                    for v in varlist:

   135

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

   136

                            last_FB = v 

   137

                        if v["C_path"] == problematic_node:

   138

                            break

   139

                    if last_FB is not None:

   140

                        failing_parent = last_FB["type"]

   141

                        message += "\n"

   142

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

   143

   144

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

   145

                    cause, problematic_node = placement_result

   146

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

   147

                        ".".join(problematic_node.path),

   148

                        ".".join(new_node.path))

   149

   150

                self.FatalError("SVGHMI : " + message)

   151

   152

        if on_hmitree_update is not None:

   153

            on_hmitree_update(hmi_tree_root)

   154

   155

        variable_decl_array = []

   156

        extern_variables_declarations = []

   157

        buf_index = 0

   158

        item_count = 0

   159

        found_heartbeat = False

   160

   161

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   162

   163

        for node in hmi_tree_root.traverse():

   164

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   165

                hmi_tree_hearbeat_index = item_count

   166

                found_heartbeat = True

   167

                extern_variables_declarations += [

   168

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   169

                ]

   170

            if hasattr(node, "iectype"):

   171

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

   172

                variable_decl_array += [

   173

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

   174

                        "EXT": "_P_ENUM",

   175

                        "IN":  "_P_ENUM",

   176

                        "MEM": "_O_ENUM",

   177

                        "OUT": "_O_ENUM",

   178

                        "VAR": "_ENUM"

   179

                    }[node.vartype] + ", " +

   180

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

   181

                buf_index += sz

   182

                item_count += 1

   183

                if len(node.path) == 1:

   184

                    extern_variables_declarations += [

   185

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

   186

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

   187

                        + node.cpath + ";"]

   188

   189

        assert(found_heartbeat)

   190

   191

        # TODO : filter only requiered external declarations

   192

        for v in varlist:

   193

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

   194

                extern_variables_declarations += [

   195

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

   196

   197

        # TODO check if programs need to be declared separately

   198

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

   199

        #                                     p for p in self._ProgramList]),

   200

   201

        for CTNChild in self.GetCTR().IterChildren():

   202

            if isinstance(CTNChild, SVGHMI):

   203

                maxConnectionsTotal += CTNChild.GetParamsAttributes("SVGHMI.MaxConnections")["value"]

   204

   205

   206

        # C code to observe/access HMI tree variables

   207

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

   208

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   209

        svghmi_c_code = svghmi_c_file.read()

   210

        svghmi_c_file.close()

   211

        svghmi_c_code = svghmi_c_code % {

   212

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

   213

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

   214

            "buffer_size": buf_index,

   215

            "item_count": item_count,

   216

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

   217

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

   218

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

   219

            "max_connections": maxConnectionsTotal

   220

            }

   221

   222

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

   223

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   224

        gen_svghmi_c.write(svghmi_c_code)

   225

        gen_svghmi_c.close()

   226

   227

        # Python based WebSocket HMITree Server

   228

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

   229

        svghmiservercode = svghmiserverfile.read()

   230

        svghmiserverfile.close()

   231

   232

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

   233

        runtimefile = open(runtimefile_path, 'w')

   234

        runtimefile.write(svghmiservercode)

   235

        runtimefile.close()

   236

   237

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

   238

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

   239

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   240

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

   241

        hmitree_backup_file.close()

   242

   243

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

   244

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

   245

                #         ^

   246

                # note the double zero after "runtime_", 

   247

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

   248

   249

    def GlobalInstances(self):

   250

        """ Adds HMI tree root and hearbeat to PLC Configuration's globals """

   251

        return [(name, iec_type, "") for name, iec_type in SPECIAL_NODES]

   252

   253

   254

   255

def Register_SVGHMI_UI_for_HMI_tree_updates(ref):

   256

    global on_hmitree_update

   257

    def HMITreeUpdate(_hmi_tree_root):

   258

        obj = ref()

   259

        if obj is not None:

   260

            obj.HMITreeUpdate(_hmi_tree_root)

   261

   262

    on_hmitree_update = HMITreeUpdate

   263

   264

   265

class SVGHMIEditor(ConfTreeNodeEditor):

   266

    CONFNODEEDITOR_TABS = [

   267

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

   268

   269

    def CreateSVGHMI_UI(self, parent):

   270

        global hmi_tree_root

   271

   272

        if hmi_tree_root is None:

   273

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

   274

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

   275

            if os.path.exists(hmitree_backup_path):

   276

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   277

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

   278

   279

        ret = SVGHMI_UI(parent, Register_SVGHMI_UI_for_HMI_tree_updates)

   280

   281

        on_hmitree_update(hmi_tree_root)

   282

   283

        return ret

   284

   285

class SVGHMI(object):

   286

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

   287

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

   288

      <xsd:element name="SVGHMI">

   289

        <xsd:complexType>

   290

          <xsd:attribute name="OnStart" type="xsd:string" use="optional" default="chromium {url}"/>

   291

          <xsd:attribute name="OnStop" type="xsd:string" use="optional" default="echo 'please close chromium window at {url}'"/>

   292

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

   293

          <xsd:attribute name="WatchdogInitial" use="optional" default="30">

   294

            <xsd:simpleType>

   295

                <xsd:restriction base="xsd:integer">

   296

                    <xsd:minInclusive value="2"/>

   297

                    <xsd:maxInclusive value="600"/>

   298

                </xsd:restriction>

   299

            </xsd:simpleType>

   300

          </xsd:attribute>

   301

          <xsd:attribute name="WatchdogInterval" use="optional" default="5">

   302

            <xsd:simpleType>

   303

                <xsd:restriction base="xsd:integer">

   304

                    <xsd:minInclusive value="2"/>

   305

                    <xsd:maxInclusive value="60"/>

   306

                </xsd:restriction>

   307

            </xsd:simpleType>

   308

          </xsd:attribute>

   309

          <xsd:attribute name="Port" type="xsd:integer" use="optional" default="8008"/>

   310

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

   311

          <xsd:attribute name="Path" type="xsd:string" use="optional" default="{name}"/>

   312

          <xsd:attribute name="MaxConnections" use="optional" default="16">

   313

            <xsd:simpleType>

   314

                <xsd:restriction base="xsd:integer">

   315

                    <xsd:minInclusive value="1"/>

   316

                    <xsd:maxInclusive value="1024"/>

   317

                </xsd:restriction>

   318

            </xsd:simpleType>

   319

          </xsd:attribute>

   320

        </xsd:complexType>

   321

      </xsd:element>

   322

    </xsd:schema>

   323

    """

   324

   325

    EditorType = SVGHMIEditor

   326

   327

    ConfNodeMethods = [

   328

        {

   329

            "bitmap":    "ImportSVG",

   330

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

   331

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

   332

            "method":   "_ImportSVG"

   333

        },

   334

        {

   335

            "bitmap":    "EditSVG",

   336

            "name":    _("Inkscape"),

   337

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

   338

            "method":   "_StartInkscape"

   339

        },

   340

        {

   341

            "bitmap":    "OpenPOT",

   342

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

   343

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

   344

            "method":   "_OpenPOT"

   345

        },

   346

        {

   347

            "bitmap":    "EditPO",

   348

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

   349

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

   350

            "method":   "_EditPO"

   351

        },

   352

        {

   353

            "bitmap":    "AddFont",

   354

            "name":    _("Add Font"),

   355

            "tooltip": _("Add TTF, OTF or WOFF font to be embedded in HMI"),

   356

            "method":   "_AddFont"

   357

        },

   358

        {

   359

            "bitmap":    "DelFont",

   360

            "name":    _("Delete Font"),

   361

            "tooltip": _("Remove font previously added to HMI"),

   362

            "method":   "_DelFont"

   363

        },

   364

    ]

   365

   366

    def _getSVGpath(self, project_path=None):

   367

        if project_path is None:

   368

            project_path = self.CTNPath()

   369

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

   370

   371

    def _getPOTpath(self, project_path=None):

   372

        if project_path is None:

   373

            project_path = self.CTNPath()

   374

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

   375

   376

    def OnCTNSave(self, from_project_path=None):

   377

        if from_project_path is not None:

   378

            shutil.copyfile(self._getSVGpath(from_project_path),

   379

                            self._getSVGpath())

   380

            shutil.copyfile(self._getPOTpath(from_project_path),

   381

                            self._getPOTpath())

   382

            # XXX TODO copy .PO files

   383

        return True

   384

   385

    def GetSVGGeometry(self):

   386

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

   387

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

   388

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

   389

   390

        inkpath = get_inkscape_path()

   391

   392

        if inkpath is None:

   393

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

   394

   395

        svgpath = self._getSVGpath()

   396

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

   397

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

   398

                                                     no_stdout=True,

   399

                                                     no_stderr=True).spin()

   400

        if status != 0:

   401

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

   402

   403

        res = []

   404

        for line in result.split():

   405

            strippedline = line.strip()

   406

            attrs = dict(

   407

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

   408

   409

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

   410

   411

        self.ProgressEnd("inkscape")

   412

        return res

   413

   414

    def GetHMITree(self):

   415

        global hmi_tree_root

   416

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

   417

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

   418

        self.ProgressEnd("hmitree")

   419

        return res

   420

   421

    def GetTranslations(self, _context, msgs):

   422

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

   423

        messages = EtreeToMessages(msgs)

   424

   425

        if len(messages) == 0:

   426

            self.ProgressEnd("i18n")

   427

            return

   428

   429

        SaveCatalog(self._getPOTpath(), messages)

   430

   431

        translations = ReadTranslations(self.CTNPath())

   432

   433

        langs,translated_messages = MatchTranslations(translations, messages, 

   434

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

   435

   436

        ret = TranslationToEtree(langs,translated_messages)

   437

   438

        self.ProgressEnd("i18n")

   439

   440

        return ret

   441

   442

    def GetFontsFiles(self):

   443

        project_path = self.CTNPath()

   444

        fontdir = os.path.join(project_path, "fonts") 

   445

        if os.path.isdir(fontdir):

   446

            return [os.path.join(fontdir,f) for f in sorted(os.listdir(fontdir))]

   447

        return []

   448

   449

    def GetFonts(self, _context):

   450

        css_parts = []

   451

   452

        for fontfile in self.GetFontsFiles():

   453

            if os.path.isfile(fontfile):

   454

                css_parts.append(GetCSSFontFaceFromFontFile(fontfile))

   455

   456

        return "".join(css_parts)

   457

   458

    times_msgs = {}

   459

    indent = 1

   460

    def ProgressStart(self, k, m):

   461

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

   462

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

   463

        self.indent = self.indent + 1

   464

   465

    def ProgressEnd(self, k):

   466

        t = time.time()

   467

        oldt, m = self.times_msgs[k]

   468

        self.indent = self.indent - 1

   469

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

   470

   471

    def CTNGenerate_C(self, buildpath, locations):

   472

   473

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

   474

        view_name = self.BaseParams.getName()

   475

   476

        svgfile = self._getSVGpath()

   477

   478

        res = ([], "", False)

   479

   480

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

   481

   482

        build_path = self._getBuildPath()

   483

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

   484

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

   485

   486

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

   487

   488

        if os.path.exists(svgfile):