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

hmi_tree_root = None

    48

    49

on_hmitree_update = None

    50

    51

maxConnectionsTotal = 0

    52

    53

class SVGHMILibrary(POULibrary):

    54

    def GetLibraryPath(self):

    55

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

    56

    57

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

    58

        global hmi_tree_root, on_hmitree_update, maxConnectionsTotal

    59

    60

        maxConnectionsTotal = 0

    61

    62

        already_found_watchdog = False

    63

        found_SVGHMI_instance = False

    64

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

    65

            if isinstance(CTNChild, SVGHMI):

    66

                found_SVGHMI_instance = True

    67

                # collect maximum connection total for all svghmi nodes

    68

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

    69

    70

                # spot watchdog abuse

    71

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

    72

                    if already_found_watchdog:

    73

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

    74

                    already_found_watchdog = True

    75

    76

        if not found_SVGHMI_instance:

    77

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

    78

    79

    80

        """

    81

        PLC Instance Tree:

    82

          prog0

    83

           +->v1 HMI_INT

    84

           +->v2 HMI_INT

    85

           +->fb0 (type mhoo)

    86

           |   +->va HMI_NODE

    87

           |   +->v3 HMI_INT

    88

           |   +->v4 HMI_INT

    89

           |

    90

           +->fb1 (type mhoo)

    91

           |   +->va HMI_NODE

    92

           |   +->v3 HMI_INT

    93

           |   +->v4 HMI_INT

    94

           |

    95

           +->fb2

    96

               +->v5 HMI_IN

    97

    98

        HMI tree:

    99

          hmi0

   100

           +->v1

   101

           +->v2

   102

           +->fb0 class:va

   103

           |   +-> v3

   104

           |   +-> v4

   105

           |

   106

           +->fb1 class:va

   107

           |   +-> v3

   108

           |   +-> v4

   109

           |

   110

           +->v5

   111

   112

        """

   113

   114

        # Filter known HMI types

   115

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

   116

   117

        hmi_tree_root = None

   118

   119

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

   120

        for i,v in enumerate(hmi_types_instances):

   121

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

   122

            derived = v["derived"]

   123

            if derived == "HMI_NODE":

   124

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

   125

                hmi_types_instances.pop(i)

   126

                break

   127

   128

        # deduce HMI tree from PLC HMI_* instances

   129

        for v in hmi_types_instances:

   130

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

   131

            # ignores variables starting with _TMP_

   132

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

   133

                continue

   134

            vartype = v["vartype"]

   135

            # ignores external variables

   136

            if vartype == "EXT":

   137

                continue

   138

            derived = v["derived"]

   139

            kwargs={}

   140

            if derived == "HMI_NODE":

   141

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

   142

                name = path[-2]

   143

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

   144

            else:

   145

                name = path[-1]

   146

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

   147

            placement_result = hmi_tree_root.place_node(new_node)

   148

            if placement_result is not None:

   149

                cause, problematic_node = placement_result

   150

                if cause == "Non_Unique":

   151

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

   152

                        ".".join(problematic_node.path),

   153

                        ".".join(new_node.path))

   154

   155

                    last_FB = None 

   156

                    for _v in varlist:

   157

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

   158

                            last_FB = _v 

   159

                        if _v["C_path"] == problematic_node:

   160

                            break

   161

                    if last_FB is not None:

   162

                        failing_parent = last_FB["type"]

   163

                        message += "\n"

   164

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

   165

   166

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

   167

                    cause, problematic_node = placement_result

   168

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

   169

                        ".".join(problematic_node.path),

   170

                        ".".join(new_node.path))

   171

   172

                self.FatalError("SVGHMI : " + message)

   173

   174

        if on_hmitree_update is not None:

   175

            on_hmitree_update(hmi_tree_root)

   176

   177

        variable_decl_array = []

   178

        extern_variables_declarations = []

   179

        buf_index = 0

   180

        item_count = 0

   181

        found_heartbeat = False

   182

   183

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   184

   185

        for node in hmi_tree_root.traverse():

   186

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   187

                hmi_tree_hearbeat_index = item_count

   188

                found_heartbeat = True

   189

                extern_variables_declarations += [

   190

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   191

                ]

   192

            if hasattr(node, "iectype"):

   193

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

   194

                variable_decl_array += [

   195

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

   196

                        "EXT": "_P_ENUM",

   197

                        "IN":  "_P_ENUM",

   198

                        "MEM": "_O_ENUM",

   199

                        "OUT": "_O_ENUM",

   200

                        "VAR": "_ENUM"

   201

                    }[node.vartype] + ", " +

   202

                    str(buf_index) + ")"]

   203

                buf_index += sz

   204

                item_count += 1

   205

                if len(node.path) == 1:

   206

                    extern_variables_declarations += [

   207

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

   208

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

   209

                        + node.cpath + ";"]

   210

   211

        assert(found_heartbeat)

   212

   213

        # TODO : filter only requiered external declarations

   214

        for v in varlist:

   215

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

   216

                extern_variables_declarations += [

   217

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

   218

   219

        # TODO check if programs need to be declared separately

   220

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

   221

        #                                     p for p in self._ProgramList]),

   222

   223

        # C code to observe/access HMI tree variables

   224

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

   225

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   226

        svghmi_c_code = svghmi_c_file.read()

   227

        svghmi_c_file.close()

   228

        svghmi_c_code = svghmi_c_code % {

   229

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

   230

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

   231

            "buffer_size": buf_index,

   232

            "item_count": item_count,

   233

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

   234

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

   235

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

   236

            "max_connections": maxConnectionsTotal

   237

            }

   238

   239

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

   240

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   241

        gen_svghmi_c.write(svghmi_c_code)

   242

        gen_svghmi_c.close()

   243

   244

        # Python based WebSocket HMITree Server

   245

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

   246

        svghmiservercode = svghmiserverfile.read()

   247

        svghmiserverfile.close()

   248

   249

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

   250

        runtimefile = open(runtimefile_path, 'w')

   251

        runtimefile.write(svghmiservercode)

   252

        runtimefile.close()

   253

   254

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

   255

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

   256

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   257

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

   258

        hmitree_backup_file.close()

   259

   260

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

   261

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

   262

                #         ^

   263

                # note the double zero after "runtime_", 

   264

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

   265

   266

    def GlobalInstances(self):

   267

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

   268

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

   269

   270

   271

   272

def Register_SVGHMI_UI_for_HMI_tree_updates(ref):

   273

    global on_hmitree_update

   274

    def HMITreeUpdate(_hmi_tree_root):

   275

        obj = ref()

   276

        if obj is not None:

   277

            obj.HMITreeUpdate(_hmi_tree_root)

   278

   279

    on_hmitree_update = HMITreeUpdate

   280

   281

   282

class SVGHMIEditor(ConfTreeNodeEditor):

   283

    CONFNODEEDITOR_TABS = [

   284

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

   285

   286

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

   287

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

   288

        self.Controler = controler

   289

   290

    def CreateSVGHMI_UI(self, parent):

   291

        global hmi_tree_root

   292

   293

        if hmi_tree_root is None:

   294

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

   295

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

   296

            if os.path.exists(hmitree_backup_path):

   297

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   298

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

   299

   300

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

   301

   302

        on_hmitree_update(hmi_tree_root)

   303

   304

        return ret

   305

   306

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

   307

    default_cmds={

   308

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

   309

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

   310

elif "SNAP" in os.environ:

   311

    default_cmds={

   312

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

   313

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

   314

else:

   315

    default_cmds={

   316

        "launch":"chromium {url}",

   317

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

   318

   319

class SVGHMI(object):

   320

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

   321

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

   322

      <xsd:element name="SVGHMI">

   323

        <xsd:complexType>

   324

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

   325

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

   326

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

   327

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

   328

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

   329

            <xsd:simpleType>

   330

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

   331

                    <xsd:minInclusive value="2"/>

   332

                    <xsd:maxInclusive value="600"/>

   333

                </xsd:restriction>

   334

            </xsd:simpleType>

   335

          </xsd:attribute>

   336

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

   337

            <xsd:simpleType>

   338

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

   339

                    <xsd:minInclusive value="2"/>

   340

                    <xsd:maxInclusive value="60"/>

   341

                </xsd:restriction>

   342

            </xsd:simpleType>

   343

          </xsd:attribute>

   344

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

   345

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

   346

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

   347

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

   348

            <xsd:simpleType>

   349

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

   350

                    <xsd:minInclusive value="1"/>

   351

                    <xsd:maxInclusive value="1024"/>

   352

                </xsd:restriction>

   353

            </xsd:simpleType>

   354

          </xsd:attribute>

   355

        </xsd:complexType>

   356

      </xsd:element>

   357

    </xsd:schema>

   358

    """%default_cmds

   359

   360

    EditorType = SVGHMIEditor

   361

   362

    ConfNodeMethods = [

   363

        {

   364

            "bitmap":    "ImportSVG",

   365

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

   366

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

   367

            "method":   "_ImportSVG"

   368

        },

   369

        {

   370

            "bitmap":    "EditSVG",

   371

            "name":    _("Inkscape"),

   372

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

   373

            "method":   "_StartInkscape"

   374

        },

   375

        {

   376

            "bitmap":    "OpenPOT",

   377

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

   378

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

   379

            "method":   "_OpenPOT"

   380

        },

   381

        {

   382

            "bitmap":    "EditPO",

   383

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

   384

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

   385

            "method":   "_EditPO"

   386

        },

   387

        {

   388

            "bitmap":    "AddFont",

   389

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

   390

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

   391

            "method":   "_AddFont"

   392

        },

   393

        {

   394

            "bitmap":    "DelFont",

   395

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

   396

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

   397

            "method":   "_DelFont"

   398

        },

   399

    ]

   400

   401

    def _getSVGpath(self, project_path=None):

   402

        if project_path is None:

   403

            project_path = self.CTNPath()

   404

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

   405

   406

    def _getPOTpath(self, project_path=None):

   407

        if project_path is None:

   408

            project_path = self.CTNPath()

   409

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

   410

   411

    def OnCTNSave(self, from_project_path=None):

   412

        if from_project_path is not None:

   413

            shutil.copyfile(self._getSVGpath(from_project_path),

   414

                            self._getSVGpath())

   415

   416

            potpath = self._getPOTpath(from_project_path)

   417

            if os.path.isfile(potpath):

   418

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

   419

                # copy .PO files

   420

                for _name, pofile in GetPoFiles(from_project_path):

   421

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

   422

        return True

   423

   424

    def GetSVGGeometry(self):

   425

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

   426

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

   427

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

   428

   429

        inkpath = get_inkscape_path()

   430

        if inkpath is None:

   431

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

   432

   433

        svgpath = self._getSVGpath()

   434

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

   435

                                                     [inkpath, '-S', svgpath],

   436

                                                     no_stdout=True,

   437

                                                     no_stderr=True).spin()

   438

        if status != 0:

   439

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

   440

   441

        res = []

   442

        for line in result.split():

   443

            strippedline = line.strip()

   444

            attrs = dict(

   445

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

   446

   447

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

   448

   449

        self.ProgressEnd("inkscape")

   450

        return res

   451

   452

    def GetHMITree(self):

   453

        global hmi_tree_root

   454

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

   455

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

   456

        self.ProgressEnd("hmitree")

   457

        return res

   458

   459

    def GetTranslations(self, _context, msgs):

   460

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

   461

        messages = EtreeToMessages(msgs)

   462

   463

        if len(messages) == 0:

   464

            self.ProgressEnd("i18n")

   465

            return

   466

   467

        SaveCatalog(self._getPOTpath(), messages)

   468

   469

        translations = ReadTranslations(self.CTNPath())

   470

   471

        langs,translated_messages = MatchTranslations(translations, messages, 

   472

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

   473

   474

        ret = TranslationToEtree(langs,translated_messages)

   475

   476

        self.ProgressEnd("i18n")

   477

   478

        return ret

   479

   480

    def GetFontsFiles(self):

   481

        project_path = self.CTNPath()

   482

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

   483

        if os.path.isdir(fontdir):

   484

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

   485

        return []

   486

   487