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

            derived = v["derived"]

   134

            kwargs={}

   135

            if derived == "HMI_NODE":

   136

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

   137

                name = path[-2]

   138

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

   139

            else:

   140

                name = path[-1]

   141

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

   142

            placement_result = hmi_tree_root.place_node(new_node)

   143

            if placement_result is not None:

   144

                cause, problematic_node = placement_result

   145

                if cause == "Non_Unique":

   146

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

   147

                        ".".join(problematic_node.path),

   148

                        ".".join(new_node.path))

   149

   150

                    last_FB = None 

   151

                    for v in varlist:

   152

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

   153

                            last_FB = v 

   154

                        if v["C_path"] == problematic_node:

   155

                            break

   156

                    if last_FB is not None:

   157

                        failing_parent = last_FB["type"]

   158

                        message += "\n"

   159

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

   160

   161

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

   162

                    cause, problematic_node = placement_result

   163

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

   164

                        ".".join(problematic_node.path),

   165

                        ".".join(new_node.path))

   166

   167

                self.FatalError("SVGHMI : " + message)

   168

   169

        if on_hmitree_update is not None:

   170

            on_hmitree_update(hmi_tree_root)

   171

   172

        variable_decl_array = []

   173

        extern_variables_declarations = []

   174

        buf_index = 0

   175

        item_count = 0

   176

        found_heartbeat = False

   177

   178

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   179

   180

        for node in hmi_tree_root.traverse():

   181

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   182

                hmi_tree_hearbeat_index = item_count

   183

                found_heartbeat = True

   184

                extern_variables_declarations += [

   185

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   186

                ]

   187

            if hasattr(node, "iectype"):

   188

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

   189

                variable_decl_array += [

   190

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

   191

                        "EXT": "_P_ENUM",

   192

                        "IN":  "_P_ENUM",

   193

                        "MEM": "_O_ENUM",

   194

                        "OUT": "_O_ENUM",

   195

                        "VAR": "_ENUM"

   196

                    }[node.vartype] + ", " +

   197

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

   198

                buf_index += sz

   199

                item_count += 1

   200

                if len(node.path) == 1:

   201

                    extern_variables_declarations += [

   202

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

   203

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

   204

                        + node.cpath + ";"]

   205

   206

        assert(found_heartbeat)

   207

   208

        # TODO : filter only requiered external declarations

   209

        for v in varlist:

   210

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

   211

                extern_variables_declarations += [

   212

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

   213

   214

        # TODO check if programs need to be declared separately

   215

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

   216

        #                                     p for p in self._ProgramList]),

   217

   218

        # C code to observe/access HMI tree variables

   219

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

   220

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   221

        svghmi_c_code = svghmi_c_file.read()

   222

        svghmi_c_file.close()

   223

        svghmi_c_code = svghmi_c_code % {

   224

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

   225

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

   226

            "buffer_size": buf_index,

   227

            "item_count": item_count,

   228

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

   229

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

   230

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

   231

            "max_connections": maxConnectionsTotal

   232

            }

   233

   234

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

   235

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   236

        gen_svghmi_c.write(svghmi_c_code)

   237

        gen_svghmi_c.close()

   238

   239

        # Python based WebSocket HMITree Server

   240

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

   241

        svghmiservercode = svghmiserverfile.read()

   242

        svghmiserverfile.close()

   243

   244

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

   245

        runtimefile = open(runtimefile_path, 'w')

   246

        runtimefile.write(svghmiservercode)

   247

        runtimefile.close()

   248

   249

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

   250

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

   251

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   252

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

   253

        hmitree_backup_file.close()

   254

   255

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

   256

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

   257

                #         ^

   258

                # note the double zero after "runtime_", 

   259

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

   260

   261

    def GlobalInstances(self):

   262

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

   263

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

   264

   265

   266

   267

def Register_SVGHMI_UI_for_HMI_tree_updates(ref):

   268

    global on_hmitree_update

   269

    def HMITreeUpdate(_hmi_tree_root):

   270

        obj = ref()

   271

        if obj is not None:

   272

            obj.HMITreeUpdate(_hmi_tree_root)

   273

   274

    on_hmitree_update = HMITreeUpdate

   275

   276

   277

class SVGHMIEditor(ConfTreeNodeEditor):

   278

    CONFNODEEDITOR_TABS = [

   279

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

   280

   281

    def CreateSVGHMI_UI(self, parent):

   282

        global hmi_tree_root

   283

   284

        if hmi_tree_root is None:

   285

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

   286

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

   287

            if os.path.exists(hmitree_backup_path):

   288

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   289

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

   290

   291

        ret = SVGHMI_UI(parent, Register_SVGHMI_UI_for_HMI_tree_updates)

   292

   293

        on_hmitree_update(hmi_tree_root)

   294

   295

        return ret

   296

   302

class SVGHMI(object):

   303

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

   304

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

   305

      <xsd:element name="SVGHMI">

   306

        <xsd:complexType>

   310

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

   311

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

   312

            <xsd:simpleType>

   313

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

   314

                    <xsd:minInclusive value="2"/>

   315

                    <xsd:maxInclusive value="600"/>

   316

                </xsd:restriction>

   317

            </xsd:simpleType>

   318

          </xsd:attribute>

   319

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

   320

            <xsd:simpleType>

   321

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

   322

                    <xsd:minInclusive value="2"/>

   323

                    <xsd:maxInclusive value="60"/>

   324

                </xsd:restriction>

   325

            </xsd:simpleType>

   326

          </xsd:attribute>

   327

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

   328

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

   329

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

   330

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

   331

            <xsd:simpleType>

   332

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

   333

                    <xsd:minInclusive value="1"/>

   334

                    <xsd:maxInclusive value="1024"/>

   335

                </xsd:restriction>

   336

            </xsd:simpleType>

   337

          </xsd:attribute>

   338

        </xsd:complexType>

   339

      </xsd:element>

   340

    </xsd:schema>

   342

   343

    EditorType = SVGHMIEditor

   344

   345

    ConfNodeMethods = [

   346

        {

   347

            "bitmap":    "ImportSVG",

   348

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

   349

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

   350

            "method":   "_ImportSVG"

   351

        },

   352

        {

   353

            "bitmap":    "EditSVG",

   354

            "name":    _("Inkscape"),

   355

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

   356

            "method":   "_StartInkscape"

   357

        },

   358

        {

   359

            "bitmap":    "OpenPOT",

   360

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

   361

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

   362

            "method":   "_OpenPOT"

   363

        },

   364

        {

   365

            "bitmap":    "EditPO",

   366

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

   367

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

   368

            "method":   "_EditPO"

   369

        },

   370

        {

   371

            "bitmap":    "AddFont",

   372

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

   373

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

   374

            "method":   "_AddFont"

   375

        },

   376

        {

   377

            "bitmap":    "DelFont",

   378

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

   379

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

   380

            "method":   "_DelFont"

   381

        },

   382

    ]

   383

   384

    def _getSVGpath(self, project_path=None):

   385

        if project_path is None:

   386

            project_path = self.CTNPath()

   387

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

   388

   389

    def _getPOTpath(self, project_path=None):

   390

        if project_path is None:

   391

            project_path = self.CTNPath()

   392

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

   393

   394

    def OnCTNSave(self, from_project_path=None):

   395

        if from_project_path is not None:

   396

            shutil.copyfile(self._getSVGpath(from_project_path),

   397

                            self._getSVGpath())

   398

            shutil.copyfile(self._getPOTpath(from_project_path),

   399

                            self._getPOTpath())

   400

            # XXX TODO copy .PO files

   401

        return True

   402

   403

    def GetSVGGeometry(self):

   404

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

   405

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

   406

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

   407

   408

        inkpath = get_inkscape_path()

   409

   410

        if inkpath is None:

   411

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

   412

   413

        svgpath = self._getSVGpath()

   414

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

   415

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

   416

                                                     no_stdout=True,

   417

                                                     no_stderr=True).spin()

   418

        if status != 0:

   419

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

   420

   421

        res = []

   422

        for line in result.split():

   423

            strippedline = line.strip()

   424

            attrs = dict(

   425

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

   426

   427

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

   428

   429

        self.ProgressEnd("inkscape")

   430

        return res

   431

   432

    def GetHMITree(self):

   433

        global hmi_tree_root

   434

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

   435

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

   436

        self.ProgressEnd("hmitree")

   437

        return res

   438

   439

    def GetTranslations(self, _context, msgs):

   440

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

   441

        messages = EtreeToMessages(msgs)

   442

   443

        if len(messages) == 0:

   444

            self.ProgressEnd("i18n")

   445

            return

   446

   447

        SaveCatalog(self._getPOTpath(), messages)

   448

   449

        translations = ReadTranslations(self.CTNPath())

   450

   451

        langs,translated_messages = MatchTranslations(translations, messages, 

   452

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

   453

   454

        ret = TranslationToEtree(langs,translated_messages)

   455

   456

        self.ProgressEnd("i18n")

   457

   458

        return ret

   459

   460

    def GetFontsFiles(self):

   461

        project_path = self.CTNPath()

   462

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

   463

        if os.path.isdir(fontdir):

   464

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

   465

        return []

   466

   467

    def GetFonts(self, _context):

   468

        css_parts = []

   469

   470

        for fontfile in self.GetFontsFiles():

   471

            if os.path.isfile(fontfile):

   472

                css_parts.append(GetCSSFontFaceFromFontFile(fontfile))

   473

   474

        return "".join(css_parts)

   475

   476

    times_msgs = {}

   477

    indent = 1

   478

    def ProgressStart(self, k, m):

   479

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

   480

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

   481

        self.indent = self.indent + 1

   482

   483

    def ProgressEnd(self, k):

   484

        t = time.time()

   485

        oldt, m = self.times_msgs[k]

   486

        self.indent = self.indent - 1

   487

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

   488