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

        already_found_watchdog = False

    60

        found_SVGHMI_instance = False

    61

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

    62

            if isinstance(CTNChild, SVGHMI):

    63

                found_SVGHMI_instance = True

    64

                # collect maximum connection total for all svghmi nodes

    65

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

    66

    67

                # spot watchdog abuse

    68

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

    69

                    if already_found_watchdog:

    70

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

    71

                    already_found_watchdog = True

    72

    73

        if not found_SVGHMI_instance:

    74

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

    75

    76

    77

        """

    78

        PLC Instance Tree:

    79

          prog0

    80

           +->v1 HMI_INT

    81

           +->v2 HMI_INT

    82

           +->fb0 (type mhoo)

    83

           |   +->va HMI_NODE

    84

           |   +->v3 HMI_INT

    85

           |   +->v4 HMI_INT

    86

           |

    87

           +->fb1 (type mhoo)

    88

           |   +->va HMI_NODE

    89

           |   +->v3 HMI_INT

    90

           |   +->v4 HMI_INT

    91

           |

    92

           +->fb2

    93

               +->v5 HMI_IN

    94

    95

        HMI tree:

    96

          hmi0

    97

           +->v1

    98

           +->v2

    99

           +->fb0 class:va

   100

           |   +-> v3

   101

           |   +-> v4

   102

           |

   103

           +->fb1 class:va

   104

           |   +-> v3

   105

           |   +-> v4

   106

           |

   107

           +->v5

   108

   109

        """

   110

   111

        # Filter known HMI types

   112

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

   113

   114

        hmi_tree_root = None

   115

   116

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

   117

        for i,v in enumerate(hmi_types_instances):

   118

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

   119

            derived = v["derived"]

   120

            if derived == "HMI_NODE":

   121

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

   122

                hmi_types_instances.pop(i)

   123

                break

   124

   125

        # deduce HMI tree from PLC HMI_* instances

   126

        for v in hmi_types_instances:

   127

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

   128

            # ignores variables starting with _TMP_

   129

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

   130

                continue

   131

            derived = v["derived"]

   132

            kwargs={}

   133

            if derived == "HMI_NODE":

   134

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

   135

                name = path[-2]

   136

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

   137

            else:

   138

                name = path[-1]

   139

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

   140

            placement_result = hmi_tree_root.place_node(new_node)

   141

            if placement_result is not None:

   142

                cause, problematic_node = placement_result

   143

                if cause == "Non_Unique":

   144

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

   145

                        ".".join(problematic_node.path),

   146

                        ".".join(new_node.path))

   147

   148

                    last_FB = None 

   149

                    for v in varlist:

   150

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

   151

                            last_FB = v 

   152

                        if v["C_path"] == problematic_node:

   153

                            break

   154

                    if last_FB is not None:

   155

                        failing_parent = last_FB["type"]

   156

                        message += "\n"

   157

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

   158

   159

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

   160

                    cause, problematic_node = placement_result

   161

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

   162

                        ".".join(problematic_node.path),

   163

                        ".".join(new_node.path))

   164

   165

                self.FatalError("SVGHMI : " + message)

   166

   167

        if on_hmitree_update is not None:

   168

            on_hmitree_update(hmi_tree_root)

   169

   170

        variable_decl_array = []

   171

        extern_variables_declarations = []

   172

        buf_index = 0

   173

        item_count = 0

   174

        found_heartbeat = False

   175

   176

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   177

   178

        for node in hmi_tree_root.traverse():

   179

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   180

                hmi_tree_hearbeat_index = item_count

   181

                found_heartbeat = True

   182

                extern_variables_declarations += [

   183

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   184

                ]

   185

            if hasattr(node, "iectype"):

   186

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

   187

                variable_decl_array += [

   188

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

   189

                        "EXT": "_P_ENUM",

   190

                        "IN":  "_P_ENUM",

   191

                        "MEM": "_O_ENUM",

   192

                        "OUT": "_O_ENUM",

   193

                        "VAR": "_ENUM"

   194

                    }[node.vartype] + ", " +

   195

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

   196

                buf_index += sz

   197

                item_count += 1

   198

                if len(node.path) == 1:

   199

                    extern_variables_declarations += [

   200

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

   201

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

   202

                        + node.cpath + ";"]

   203

   204

        assert(found_heartbeat)

   205

   206

        # TODO : filter only requiered external declarations

   207

        for v in varlist:

   208

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

   209

                extern_variables_declarations += [

   210

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

   211

   212

        # TODO check if programs need to be declared separately

   213

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

   214

        #                                     p for p in self._ProgramList]),

   215

   216

        # C code to observe/access HMI tree variables

   217

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

   218

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   219

        svghmi_c_code = svghmi_c_file.read()

   220

        svghmi_c_file.close()

   221

        svghmi_c_code = svghmi_c_code % {

   222

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

   223

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

   224

            "buffer_size": buf_index,

   225

            "item_count": item_count,

   226

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

   227

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

   228

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

   229

            "max_connections": maxConnectionsTotal

   230

            }

   231

   232

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

   233

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   234

        gen_svghmi_c.write(svghmi_c_code)

   235

        gen_svghmi_c.close()

   236

   237

        # Python based WebSocket HMITree Server

   238

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

   239

        svghmiservercode = svghmiserverfile.read()

   240

        svghmiserverfile.close()

   241

   242

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

   243

        runtimefile = open(runtimefile_path, 'w')

   244

        runtimefile.write(svghmiservercode)

   245

        runtimefile.close()

   246

   247

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

   248

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

   249

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   250

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

   251

        hmitree_backup_file.close()

   252

   253

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

   254

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

   255

                #         ^

   256

                # note the double zero after "runtime_", 

   257

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

   258

   259

    def GlobalInstances(self):

   260

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

   261

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

   262

   263

   264

   265

def Register_SVGHMI_UI_for_HMI_tree_updates(ref):

   266

    global on_hmitree_update

   267

    def HMITreeUpdate(_hmi_tree_root):

   268

        obj = ref()

   269

        if obj is not None:

   270

            obj.HMITreeUpdate(_hmi_tree_root)

   271

   272

    on_hmitree_update = HMITreeUpdate

   273

   274

   275

class SVGHMIEditor(ConfTreeNodeEditor):

   276

    CONFNODEEDITOR_TABS = [

   277

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

   278

   279

    def CreateSVGHMI_UI(self, parent):

   280

        global hmi_tree_root

   281

   282

        if hmi_tree_root is None:

   283

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

   284

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

   285

            if os.path.exists(hmitree_backup_path):

   286

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   287

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

   288

   289

        ret = SVGHMI_UI(parent, Register_SVGHMI_UI_for_HMI_tree_updates)

   290

   291

        on_hmitree_update(hmi_tree_root)

   292

   293

        return ret

   294

   300

class SVGHMI(object):

   301

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

   302

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

   303

      <xsd:element name="SVGHMI">

   304

        <xsd:complexType>

   308

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

   309

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

   310

            <xsd:simpleType>

   311

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

   312

                    <xsd:minInclusive value="2"/>

   313

                    <xsd:maxInclusive value="600"/>

   314

                </xsd:restriction>

   315

            </xsd:simpleType>

   316

          </xsd:attribute>

   317

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

   318

            <xsd:simpleType>

   319

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

   320

                    <xsd:minInclusive value="2"/>

   321

                    <xsd:maxInclusive value="60"/>

   322

                </xsd:restriction>

   323

            </xsd:simpleType>

   324

          </xsd:attribute>

   325

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

   326

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

   327

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

   328

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

   329

            <xsd:simpleType>

   330

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

   331

                    <xsd:minInclusive value="1"/>

   332

                    <xsd:maxInclusive value="1024"/>

   333

                </xsd:restriction>

   334

            </xsd:simpleType>

   335

          </xsd:attribute>

   336

        </xsd:complexType>

   337

      </xsd:element>

   338

    </xsd:schema>

   340

   341

    EditorType = SVGHMIEditor

   342

   343

    ConfNodeMethods = [

   344

        {

   345

            "bitmap":    "ImportSVG",

   346

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

   347

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

   348

            "method":   "_ImportSVG"

   349

        },

   350

        {

   351

            "bitmap":    "EditSVG",

   352

            "name":    _("Inkscape"),

   353

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

   354

            "method":   "_StartInkscape"

   355

        },

   356

        {

   357

            "bitmap":    "OpenPOT",

   358

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

   359

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

   360

            "method":   "_OpenPOT"

   361

        },

   362

        {

   363

            "bitmap":    "EditPO",

   364

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

   365

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

   366

            "method":   "_EditPO"

   367

        },

   368

        {

   369

            "bitmap":    "AddFont",

   370

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

   371

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

   372

            "method":   "_AddFont"

   373

        },

   374

        {

   375

            "bitmap":    "DelFont",

   376

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

   377

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

   378

            "method":   "_DelFont"

   379

        },

   380

    ]

   381

   382

    def _getSVGpath(self, project_path=None):

   383

        if project_path is None:

   384

            project_path = self.CTNPath()

   385

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

   386

   387

    def _getPOTpath(self, project_path=None):

   388

        if project_path is None:

   389

            project_path = self.CTNPath()

   390

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

   391

   392

    def OnCTNSave(self, from_project_path=None):

   393

        if from_project_path is not None:

   394

            shutil.copyfile(self._getSVGpath(from_project_path),

   395

                            self._getSVGpath())

   396

            shutil.copyfile(self._getPOTpath(from_project_path),

   397

                            self._getPOTpath())

   398

            # XXX TODO copy .PO files

   399

        return True

   400

   401

    def GetSVGGeometry(self):

   402

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

   403

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

   404

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

   405

   406

        inkpath = get_inkscape_path()

   407

   408

        if inkpath is None:

   409

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

   410

   411

        svgpath = self._getSVGpath()

   412

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

   413

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

   414

                                                     no_stdout=True,

   415

                                                     no_stderr=True).spin()

   416

        if status != 0:

   417

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

   418

   419

        res = []

   420

        for line in result.split():

   421

            strippedline = line.strip()

   422

            attrs = dict(

   423

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

   424

   425

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

   426

   427

        self.ProgressEnd("inkscape")

   428

        return res

   429

   430

    def GetHMITree(self):

   431

        global hmi_tree_root

   432

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

   433

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

   434

        self.ProgressEnd("hmitree")

   435

        return res

   436

   437

    def GetTranslations(self, _context, msgs):

   438

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

   439

        messages = EtreeToMessages(msgs)

   440

   441

        if len(messages) == 0:

   442

            self.ProgressEnd("i18n")

   443

            return

   444

   445

        SaveCatalog(self._getPOTpath(), messages)

   446

   447

        translations = ReadTranslations(self.CTNPath())

   448

   449

        langs,translated_messages = MatchTranslations(translations, messages, 

   450

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

   451

   452

        ret = TranslationToEtree(langs,translated_messages)

   453

   454

        self.ProgressEnd("i18n")

   455

   456

        return ret

   457

   458

    def GetFontsFiles(self):

   459

        project_path = self.CTNPath()

   460

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

   461

        if os.path.isdir(fontdir):

   462

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

   463

        return []

   464

   465

    def GetFonts(self, _context):

   466

        css_parts = []

   467

   468

        for fontfile in self.GetFontsFiles():

   469

            if os.path.isfile(fontfile):

   470

                css_parts.append(GetCSSFontFaceFromFontFile(fontfile))

   471

   472

        return "".join(css_parts)

   473

   474

    times_msgs = {}

   475

    indent = 1

   476

    def ProgressStart(self, k, m):

   477

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

   478

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

   479

        self.indent = self.indent + 1

   480

   481

    def ProgressEnd(self, k):

   482

        t = time.time()

   483

        oldt, m = self.times_msgs[k]

   484

        self.indent = self.indent - 1

   485

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

   486

   487

    def get_SVGHMI_options(self):