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

        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

                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

        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

                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 = 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

        if on_hmitree_update is not None:

   174

            on_hmitree_update(hmi_tree_root)

   175

   176

        variable_decl_array = []

   177

        extern_variables_declarations = []

   178

        buf_index = 0

   179

        item_count = 0

   180

        found_heartbeat = False

   181

   182

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   183

   184

        for node in hmi_tree_root.traverse():

   185

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   186

                hmi_tree_hearbeat_index = item_count

   187

                found_heartbeat = True

   188

                extern_variables_declarations += [

   189

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   190

                ]

   191

            if hasattr(node, "iectype"):

   192

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

   193

                variable_decl_array += [

   194

                    "HMITREE_ITEM_INITIALIZER(" + node.cpath + ", " + 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) + ")"]

   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

                        + node.cpath + ";"]

   209

   210

        assert(found_heartbeat)

   211

   212

        # TODO : filter only requiered external declarations

   213

        for v in varlist:

   214

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

   215

                extern_variables_declarations += [

   216

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

   217

   218

        # TODO check if programs need to be declared separately

   219

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

   220

        #                                     p for p in self._ProgramList]),

   221

   222

        # C code to observe/access HMI tree variables

   223

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

   224

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   225

        svghmi_c_code = svghmi_c_file.read()

   226

        svghmi_c_file.close()

   227

        svghmi_c_code = svghmi_c_code % {

   228

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

   229

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

   230

            "buffer_size": buf_index,

   231

            "item_count": item_count,

   232

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

   233

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

   234

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

   235

            "max_connections": maxConnectionsTotal

   236

            }

   237

   238

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

   239

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   240

        gen_svghmi_c.write(svghmi_c_code)

   241

        gen_svghmi_c.close()

   242

   243

        # Python based WebSocket HMITree Server

   244

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

   245

        svghmiservercode = svghmiserverfile.read()

   246

        svghmiserverfile.close()

   247

   248

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

   249

        runtimefile = open(runtimefile_path, 'w')

   250

        runtimefile.write(svghmiservercode)

   251

        runtimefile.close()

   252

   253

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

   254

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

   255

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   256

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

   257

        hmitree_backup_file.close()

   258

   259

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

   260

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

   261

                #         ^

   262

                # note the double zero after "runtime_", 

   263

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

   264

   265

    def GlobalInstances(self):

   266

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

   267

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

   268

   269

   270

   271

def Register_SVGHMI_UI_for_HMI_tree_updates(ref):

   272

    global on_hmitree_update

   273

    def HMITreeUpdate(_hmi_tree_root):

   274

        obj = ref()

   275

        if obj is not None:

   276

            obj.HMITreeUpdate(_hmi_tree_root)

   277

   278

    on_hmitree_update = HMITreeUpdate

   279

   280

   281

class SVGHMIEditor(ConfTreeNodeEditor):

   282

    CONFNODEEDITOR_TABS = [

   283

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

   284

   285

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

   286

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

   287

        self.Controler = controler

   288

   289

    def CreateSVGHMI_UI(self, parent):

   290

        global hmi_tree_root

   291

   292

        if hmi_tree_root is None:

   293

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

   294

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

   295

            if os.path.exists(hmitree_backup_path):

   296

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   297

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

   298

   299

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

   300

   301

        on_hmitree_update(hmi_tree_root)

   302

   303

        return ret

   304

   305

if wx.Platform == '__WXMSW__':

   306

    default_cmds={

   307

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

   308

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

   309

else:

   310

    default_cmds={

   311

        "launch":"chromium {url}",

   312

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

   313

   314

class SVGHMI(object):

   315

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

   316

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

   317

      <xsd:element name="SVGHMI">

   318

        <xsd:complexType>

   319

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

   320

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

   321

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

   322

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

   323

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

   324

            <xsd:simpleType>

   325

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

   326

                    <xsd:minInclusive value="2"/>

   327

                    <xsd:maxInclusive value="600"/>

   328

                </xsd:restriction>

   329

            </xsd:simpleType>

   330

          </xsd:attribute>

   331

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

   332

            <xsd:simpleType>

   333

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

   334

                    <xsd:minInclusive value="2"/>

   335

                    <xsd:maxInclusive value="60"/>

   336

                </xsd:restriction>

   337

            </xsd:simpleType>

   338

          </xsd:attribute>

   339

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

   340

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

   341

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

   342

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

   343

            <xsd:simpleType>

   344

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

   345

                    <xsd:minInclusive value="1"/>

   346

                    <xsd:maxInclusive value="1024"/>

   347

                </xsd:restriction>

   348

            </xsd:simpleType>

   349

          </xsd:attribute>

   350

        </xsd:complexType>

   351

      </xsd:element>

   352

    </xsd:schema>

   353

    """%default_cmds

   354

   355

    EditorType = SVGHMIEditor

   356

   357

    ConfNodeMethods = [

   358

        {

   359

            "bitmap":    "ImportSVG",

   360

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

   361

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

   362

            "method":   "_ImportSVG"

   363

        },

   364

        {

   365

            "bitmap":    "EditSVG",

   366

            "name":    _("Inkscape"),

   367

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

   368

            "method":   "_StartInkscape"

   369

        },

   370

        {

   371

            "bitmap":    "OpenPOT",

   372

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

   373

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

   374

            "method":   "_OpenPOT"

   375

        },

   376

        {

   377

            "bitmap":    "EditPO",

   378

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

   379

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

   380

            "method":   "_EditPO"

   381

        },

   382

        {

   383

            "bitmap":    "AddFont",

   384

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

   385

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

   386

            "method":   "_AddFont"

   387

        },

   388

        {

   389

            "bitmap":    "DelFont",

   390

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

   391

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

   392

            "method":   "_DelFont"

   393

        },

   394

    ]

   395

   396

    def _getSVGpath(self, project_path=None):

   397

        if project_path is None:

   398

            project_path = self.CTNPath()

   399

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

   400

   401

    def _getPOTpath(self, project_path=None):

   402

        if project_path is None:

   403

            project_path = self.CTNPath()

   404

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

   405

   406

    def OnCTNSave(self, from_project_path=None):

   407

        if from_project_path is not None:

   408

            shutil.copyfile(self._getSVGpath(from_project_path),

   409

                            self._getSVGpath())

   410

   411

            potpath = self._getPOTpath(from_project_path)

   412

            if os.path.isfile(potpath):

   413

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

   414

                # copy .PO files

   415

                for _name, pofile in GetPoFiles(from_project_path):

   416

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

   417

        return True

   418

   419

    def GetSVGGeometry(self):

   420

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

   421

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

   422

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

   423

   424

        inkpath = get_inkscape_path()

   425

   426

        if inkpath is None:

   427

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

   428

   429

        svgpath = self._getSVGpath()

   430

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

   431

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

   432

                                                     no_stdout=True,

   433

                                                     no_stderr=True).spin()

   434

        if status != 0:

   435

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

   436

   437

        res = []

   438

        for line in result.split():

   439

            strippedline = line.strip()

   440

            attrs = dict(

   441

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

   442

   443

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

   444

   445

        self.ProgressEnd("inkscape")

   446

        return res

   447

   448

    def GetHMITree(self):

   449

        global hmi_tree_root

   450

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

   451

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

   452

        self.ProgressEnd("hmitree")

   453

        return res

   454

   455

    def GetTranslations(self, _context, msgs):

   456

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

   457

        messages = EtreeToMessages(msgs)

   458

   459

        if len(messages) == 0:

   460

            self.ProgressEnd("i18n")

   461

            return

   462

   463

        SaveCatalog(self._getPOTpath(), messages)

   464

   465

        translations = ReadTranslations(self.CTNPath())

   466

   467

        langs,translated_messages = MatchTranslations(translations, messages, 

   468

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

   469

   470

        ret = TranslationToEtree(langs,translated_messages)

   471

   472

        self.ProgressEnd("i18n")

   473

   474

        return ret

   475

   476

    def GetFontsFiles(self):

   477

        project_path = self.CTNPath()

   478

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

   479

        if os.path.isdir(fontdir):

   480

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

   481

        return []

   482

   483

    def GetFonts(self, _context):

   484

        css_parts = []

   485

   486

        for fontfile in self.GetFontsFiles():

   487

            if os.path.isfile(fontfile):