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

    10

import os

    11

import sys

    12

import shutil

    13

import hashlib

    14

import shlex

    15

import time

    16

    17

import wx

    18

    19

from lxml import etree

    20

from lxml.etree import XSLTApplyError

    21

    22

import util.paths as paths

    23

from POULibrary import POULibrary

    24

from docutil import open_svg, get_inkscape_path

    25

    26

from util.ProcessLogger import ProcessLogger

    27

from runtime.typemapping import DebugTypesSize

    28

import targets

    29

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    30

from XSLTransform import XSLTransform

    31

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

    32

                        MatchTranslations, TranslationToEtree, open_pofile,\

    33

                        GetPoFiles

    34

from svghmi.hmi_tree import HMI_TYPES, HMITreeNode, SPECIAL_NODES 

    35

from svghmi.ui import SVGHMI_UI

    36

from svghmi.fonts import GetFontTypeAndFamilyName, GetCSSFontFaceFromFontFile

    37

    38

    39

ScriptDirectory = paths.AbsDir(__file__)

    40

    41

    42

# module scope for HMITree root

    43

# so that CTN can use HMITree deduced in Library

    44

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

    45

#       systematicaly invoked before CTN's CTNGenerate_C

    46

    47

    48

class SVGHMILibrary(POULibrary):

    49

    50

    hmi_tree_root = None

    51

    52

    maxConnectionsTotal = 0

    53

    54

    def GetLibraryPath(self):

    55

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

    56

    57

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

    58

    59

        self.maxConnectionsTotal = 0

    60

    61

        already_found_watchdog = False

    62

        found_SVGHMI_instance = False

    63

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

    64

            if isinstance(CTNChild, SVGHMI):

    65

                found_SVGHMI_instance = True

    66

                # collect maximum connection total for all svghmi nodes

    67

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

    68

    69

                # spot watchdog abuse

    70

                if CTNChild.GetParamsAttributes("SVGHMI.EnableWatchdog")["value"]:

    71

                    if already_found_watchdog:

    72

                        self.FatalError("SVGHMI: Only one watchdog enabled HMI allowed")

    73

                    already_found_watchdog = True

    74

    75

        if not found_SVGHMI_instance:

    76

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

    77

    78

    79

        """

    80

        PLC Instance Tree:

    81

          prog0

    82

           +->v1 HMI_INT

    83

           +->v2 HMI_INT

    84

           +->fb0 (type mhoo)

    85

           |   +->va HMI_NODE

    86

           |   +->v3 HMI_INT

    87

           |   +->v4 HMI_INT

    88

           |

    89

           +->fb1 (type mhoo)

    90

           |   +->va HMI_NODE

    91

           |   +->v3 HMI_INT

    92

           |   +->v4 HMI_INT

    93

           |

    94

           +->fb2

    95

               +->v5 HMI_IN

    96

    97

        HMI tree:

    98

          hmi0

    99

           +->v1

   100

           +->v2

   101

           +->fb0 class:va

   102

           |   +-> v3

   103

           |   +-> v4

   104

           |

   105

           +->fb1 class:va

   106

           |   +-> v3

   107

           |   +-> v4

   108

           |

   109

           +->v5

   110

   111

        """

   112

   113

        # Filter known HMI types

   114

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

   115

   116

        self.hmi_tree_root = None

   117

   118

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

   119

        for i,v in enumerate(hmi_types_instances):

   120

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

   121

            derived = v["derived"]

   122

            if derived == "HMI_NODE":

   123

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

   124

                hmi_types_instances.pop(i)

   125

                break

   126

   127

        # deduce HMI tree from PLC HMI_* instances

   128

        for v in hmi_types_instances:

   129

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

   130

            # ignores variables starting with _TMP_

   131

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

   132

                continue

   133

            vartype = v["vartype"]

   134

            # ignores external variables

   135

            if vartype == "EXT":

   136

                continue

   137

            derived = v["derived"]

   138

            kwargs={}

   139

            if derived == "HMI_NODE":

   140

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

   141

                name = path[-2]

   142

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

   143

            else:

   144

                name = path[-1]

   145

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

   146

            placement_result = self.hmi_tree_root.place_node(new_node)

   147

            if placement_result is not None:

   148

                cause, problematic_node = placement_result

   149

                if cause == "Non_Unique":

   150

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

   151

                        ".".join(problematic_node.path),

   152

                        ".".join(new_node.path))

   153

   154

                    last_FB = None 

   155

                    for _v in varlist:

   156

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

   157

                            last_FB = _v 

   158

                        if _v["C_path"] == problematic_node:

   159

                            break

   160

                    if last_FB is not None:

   161

                        failing_parent = last_FB["type"]

   162

                        message += "\n"

   163

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

   164

   165

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

   166

                    cause, problematic_node = placement_result

   167

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

   168

                        ".".join(problematic_node.path),

   169

                        ".".join(new_node.path))

   170

   171

                self.FatalError("SVGHMI : " + message)

   172

   173

        self.on_hmitree_update()

   174

   175

        variable_decl_array = []

   176

        extern_variables_declarations = []

   177

        buf_index = 0

   178

        item_count = 0

   179

        found_heartbeat = False

   180

   181

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   182

   183

        for node in self.hmi_tree_root.traverse():

   184

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   185

                hmi_tree_hearbeat_index = item_count

   186

                found_heartbeat = True

   187

                extern_variables_declarations += [

   188

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   189

                ]

   190

            if hasattr(node, "iectype"):

   191

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

   192

                variable_decl_array += [

   193

                    "HMITREE_ITEM_INITIALIZER(" + node.cpath + ", " + node.iectype + {

   194

                        "EXT": "_P_ENUM",

   195

                        "IN":  "_P_ENUM",

   196

                        "MEM": "_O_ENUM",

   197

                        "OUT": "_O_ENUM",

   198

                        "VAR": "_ENUM"

   199

                    }[node.vartype] + ", " +

   200

                    str(buf_index) + ")"]

   201

                buf_index += sz

   202

                item_count += 1

   203

                if len(node.path) == 1:

   204

                    extern_variables_declarations += [

   205

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

   206

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

   207

                        + node.cpath + ";"]

   208

   209

        assert(found_heartbeat)

   210

   211

        # TODO : filter only requiered external declarations

   212

        for v in varlist:

   213

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

   214

                extern_variables_declarations += [

   215

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

   216

   217

        # TODO check if programs need to be declared separately

   218

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

   219

        #                                     p for p in self._ProgramList]),

   220

   221

        # C code to observe/access HMI tree variables

   222

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

   223

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   224

        svghmi_c_code = svghmi_c_file.read()

   225

        svghmi_c_file.close()

   226

        svghmi_c_code = svghmi_c_code % {

   227

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

   228

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

   229

            "buffer_size": buf_index,

   230

            "item_count": item_count,

   231

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

   232

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

   233

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

   234

            "max_connections": self.maxConnectionsTotal

   235

            }

   236

   237

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

   238

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   239

        gen_svghmi_c.write(svghmi_c_code)

   240

        gen_svghmi_c.close()

   241

   242

        # Python based WebSocket HMITree Server

   243

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

   244

        svghmiservercode = svghmiserverfile.read()

   245

        svghmiserverfile.close()

   246

   247

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

   248

        runtimefile = open(runtimefile_path, 'w')

   249

        runtimefile.write(svghmiservercode)

   250

        runtimefile.close()

   251

   252

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

   253

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

   254

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   255

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

   256

        hmitree_backup_file.close()

   257

   258

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

   259

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

   260

                #         ^

   261

                # note the double zero after "runtime_", 

   262

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

   263

   264

    def GlobalInstances(self):

   265

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

   266

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

   267

   268

   269

    registered_uis = []

   270

    def on_hmitree_update(self):

   271

        for uiref in self.registered_uis[:]:

   272

            obj = uiref()

   273

            if obj is None:

   274

                self.registered_uis.remove(uiref)

   275

            else:

   276

                obj.HMITreeUpdate(self.hmi_tree_root)

   277

   278

   279

    def Register_SVGHMI_UI_for_HMI_tree_updates(self, uiref):

   280

        self.registered_uis.append(uiref)

   281

   282

   283

class SVGHMIEditor(ConfTreeNodeEditor):

   284

    CONFNODEEDITOR_TABS = [

   285

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

   286

   287

    def __init__(self, parent, controler, window):

   288

        ConfTreeNodeEditor.__init__(self, parent, controler, window)

   289

        self.Controler = controler

   290

   291

    def CreateSVGHMI_UI(self, parent):

   292

        ctroot = self.Controler.GetCTRoot()

   293

        svghmilib = ctroot.Libraries["SVGHMI"]

   294

   295

        if svghmilib.hmi_tree_root is None:

   296

            buildpath = ctroot._getBuildPath()

   297

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

   298

            if os.path.exists(hmitree_backup_path):

   299

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   300

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

   301

   302

        ret = SVGHMI_UI(parent, self.Controler, svghmilib.Register_SVGHMI_UI_for_HMI_tree_updates)

   303

   304

        svghmilib.on_hmitree_update()

   305

   306

        return ret

   307

   308

if sys.platform.startswith('win'):

   309

    default_cmds={

   310

        "launch":"cmd.exe /c 'start msedge {url}'",

   311

        "watchdog":"cmd.exe /k 'echo watchdog for {url} !'"}

   312

elif "SNAP" in os.environ:

   313

    default_cmds={

   314

        "launch":"xdg-open {url}",

   315

        "watchdog":"echo Watchdog for {name} !"}

   316

else:

   317

    default_cmds={

   318

        "launch":"chromium {url}",

   319

        "watchdog":"echo Watchdog for {name} !"}

   320

   321

class SVGHMI(object):

   322

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

   323

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

   324

      <xsd:element name="SVGHMI">

   325

        <xsd:complexType>

   326

          <xsd:attribute name="OnStart" type="xsd:string" use="optional" default="%(launch)s"/>

   327

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

   328

          <xsd:attribute name="OnWatchdog" type="xsd:string" use="optional" default="%(watchdog)s"/>

   329

          <xsd:attribute name="SuppressBrowserOutput" type="xsd:boolean" use="optional" default="true"/>

   330

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

   331

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

   332

            <xsd:simpleType>

   333

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

   334

                    <xsd:minInclusive value="2"/>

   335

                    <xsd:maxInclusive value="600"/>

   336

                </xsd:restriction>

   337

            </xsd:simpleType>

   338

          </xsd:attribute>

   339

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

   340

            <xsd:simpleType>

   341

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

   342

                    <xsd:minInclusive value="2"/>

   343

                    <xsd:maxInclusive value="60"/>

   344

                </xsd:restriction>

   345

            </xsd:simpleType>

   346

          </xsd:attribute>

   347

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

   348

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

   349

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

   350

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

   351

            <xsd:simpleType>

   352

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

   353

                    <xsd:minInclusive value="1"/>

   354

                    <xsd:maxInclusive value="1024"/>

   355

                </xsd:restriction>

   356

            </xsd:simpleType>

   357

          </xsd:attribute>

   358

        </xsd:complexType>

   359

      </xsd:element>

   360

    </xsd:schema>

   361

    """%default_cmds

   362

   363

    EditorType = SVGHMIEditor

   364

   365

    ConfNodeMethods = [

   366

        {

   367

            "bitmap":    "ImportSVG",

   368

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

   369

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

   370

            "method":   "_ImportSVG"

   371

        },

   372

        {

   373

            "bitmap":    "EditSVG",

   374

            "name":    _("Inkscape"),

   375

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

   376

            "method":   "_StartInkscape"

   377

        },

   378

        {

   379

            "bitmap":    "OpenPOT",

   380

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

   381

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

   382

            "method":   "_OpenPOT"

   383

        },

   384

        {

   385

            "bitmap":    "EditPO",

   386

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

   387

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

   388

            "method":   "_EditPO"

   389

        },

   390

        {

   391

            "bitmap":    "AddFont",

   392

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

   393

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

   394

            "method":   "_AddFont"

   395

        },

   396

        {

   397

            "bitmap":    "DelFont",

   398

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

   399

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

   400

            "method":   "_DelFont"

   401

        },

   402

        {

   403

            "bitmap":    "AddFile",

   404

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

   405

            "tooltip": _("Add file to be served for HMI"),

   406

            "method":   "_AddFile"

   407

        },

   408

        {

   409

            "bitmap":    "DelFile",

   410

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

   411

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

   412

            "method":   "_DelFile"

   413

        },

   414

    ]

   415

   416

    def _getSVGpath(self, project_path=None):

   417

        if project_path is None:

   418

            project_path = self.CTNPath()

   419

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

   420

   421

    def _getPOTpath(self, project_path=None):

   422

        if project_path is None:

   423

            project_path = self.CTNPath()

   424

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

   425

   426

    def OnCTNSave(self, from_project_path=None):

   427

        if from_project_path is not None:

   428

            shutil.copyfile(self._getSVGpath(from_project_path),

   429

                            self._getSVGpath())

   430

   431

            potpath = self._getPOTpath(from_project_path)

   432

            if os.path.isfile(potpath):

   433

                shutil.copyfile(potpath, self._getPOTpath())

   434

                # copy .PO files

   435

                for _name, pofile in GetPoFiles(from_project_path):

   436

                    shutil.copy(pofile, self.CTNPath())

   437

        return True

   438

   439

    def GetSVGGeometry(self):

   440

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

   441

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

   442

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

   443

   444

        inkpath = get_inkscape_path().decode()

   445

        if inkpath is None:

   446

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

   447

   448

        svgpath = self._getSVGpath()

   449

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

   450

                                                     [inkpath, '-S', svgpath],

   451

                                                     no_stdout=True,

   452

                                                     no_stderr=True).spin()

   453

        if status != 0:

   454

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

   455

   456

        res = []

   457

        for line in result.split():

   458

            strippedline = line.strip()

   459

            attrs = dict(

   460

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

   461

   462

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

   463

   464

        self.ProgressEnd("inkscape")

   465

        return res

   466

   467

    def GetHMITree(self):

   468

        ctroot = self.GetCTRoot()

   469

        svghmilib = ctroot.Libraries["SVGHMI"]

   470

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

   471

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

   472

        self.ProgressEnd("hmitree")

   473

        return res

   474

   475

    def GetTranslations(self, _context, msgs):

   476

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

   477

        messages = EtreeToMessages(msgs)

   478

   479

        if len(messages) == 0:

   480

            self.ProgressEnd("i18n")

   481

            return

   482

   483

        SaveCatalog(self._getPOTpath(), messages)

   484

   485

        translations = ReadTranslations(self.CTNPath())

   486

   487

        langs,translated_messages = MatchTranslations(translations, messages,