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

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

    61

            if isinstance(CTNChild, SVGHMI):

    62

                # collect maximum connection total for all svghmi nodes

    63

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

    64

    65

                # spot watchdog abuse

    66

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

    67

                    if already_found_watchdog:

    68

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

    69

                    already_found_watchdog = True

    70

    71

    72

        """

    73

        PLC Instance Tree:

    74

          prog0

    75

           +->v1 HMI_INT

    76

           +->v2 HMI_INT

    77

           +->fb0 (type mhoo)

    78

           |   +->va HMI_NODE

    79

           |   +->v3 HMI_INT

    80

           |   +->v4 HMI_INT

    81

           |

    82

           +->fb1 (type mhoo)

    83

           |   +->va HMI_NODE

    84

           |   +->v3 HMI_INT

    85

           |   +->v4 HMI_INT

    86

           |

    87

           +->fb2

    88

               +->v5 HMI_IN

    89

    90

        HMI tree:

    91

          hmi0

    92

           +->v1

    93

           +->v2

    94

           +->fb0 class:va

    95

           |   +-> v3

    96

           |   +-> v4

    97

           |

    98

           +->fb1 class:va

    99

           |   +-> v3

   100

           |   +-> v4

   101

           |

   102

           +->v5

   103

   104

        """

   105

   106

        # Filter known HMI types

   107

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

   108

   109

        hmi_tree_root = None

   110

   111

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

   112

        for i,v in enumerate(hmi_types_instances):

   113

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

   114

            derived = v["derived"]

   115

            if derived == "HMI_NODE":

   116

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

   117

                hmi_types_instances.pop(i)

   118

                break

   119

   120

        if hmi_tree_root is None:

   121

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

   122

   123

        # deduce HMI tree from PLC HMI_* instances

   124

        for v in hmi_types_instances:

   125

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

   126

            # ignores variables starting with _TMP_

   127

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

   128

                continue

   129

            derived = v["derived"]

   130

            kwargs={}

   131

            if derived == "HMI_NODE":

   132

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

   133

                name = path[-2]

   134

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

   135

            else:

   136

                name = path[-1]

   137

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

   138

            placement_result = hmi_tree_root.place_node(new_node)

   139

            if placement_result is not None:

   140

                cause, problematic_node = placement_result

   141

                if cause == "Non_Unique":

   142

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

   143

                        ".".join(problematic_node.path),

   144

                        ".".join(new_node.path))

   145

   146

                    last_FB = None 

   147

                    for v in varlist:

   148

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

   149

                            last_FB = v 

   150

                        if v["C_path"] == problematic_node:

   151

                            break

   152

                    if last_FB is not None:

   153

                        failing_parent = last_FB["type"]

   154

                        message += "\n"

   155

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

   156

   157

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

   158

                    cause, problematic_node = placement_result

   159

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

   160

                        ".".join(problematic_node.path),

   161

                        ".".join(new_node.path))

   162

   163

                self.FatalError("SVGHMI : " + message)

   164

   165

        if on_hmitree_update is not None:

   166

            on_hmitree_update(hmi_tree_root)

   167

   168

        variable_decl_array = []

   169

        extern_variables_declarations = []

   170

        buf_index = 0

   171

        item_count = 0

   172

        found_heartbeat = False

   173

   174

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   175

   176

        for node in hmi_tree_root.traverse():

   177

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   178

                hmi_tree_hearbeat_index = item_count

   179

                found_heartbeat = True

   180

                extern_variables_declarations += [

   181

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   182

                ]

   183

            if hasattr(node, "iectype"):

   184

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

   185

                variable_decl_array += [

   186

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

   187

                        "EXT": "_P_ENUM",

   188

                        "IN":  "_P_ENUM",

   189

                        "MEM": "_O_ENUM",

   190

                        "OUT": "_O_ENUM",

   191

                        "VAR": "_ENUM"

   192

                    }[node.vartype] + ", " +

   193

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

   194

                buf_index += sz

   195

                item_count += 1

   196

                if len(node.path) == 1:

   197

                    extern_variables_declarations += [

   198

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

   199

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

   200

                        + node.cpath + ";"]

   201

   202

        assert(found_heartbeat)

   203

   204

        # TODO : filter only requiered external declarations

   205

        for v in varlist:

   206

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

   207

                extern_variables_declarations += [

   208

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

   209

   210

        # TODO check if programs need to be declared separately

   211

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

   212

        #                                     p for p in self._ProgramList]),

   213

   214

        # C code to observe/access HMI tree variables

   215

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

   216

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   217

        svghmi_c_code = svghmi_c_file.read()

   218

        svghmi_c_file.close()

   219

        svghmi_c_code = svghmi_c_code % {

   220

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

   221

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

   222

            "buffer_size": buf_index,

   223

            "item_count": item_count,

   224

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

   225

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

   226

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

   227

            "max_connections": maxConnectionsTotal

   228

            }

   229

   230

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

   231

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   232

        gen_svghmi_c.write(svghmi_c_code)

   233

        gen_svghmi_c.close()

   234

   235

        # Python based WebSocket HMITree Server

   236

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

   237

        svghmiservercode = svghmiserverfile.read()

   238

        svghmiserverfile.close()

   239

   240

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

   241

        runtimefile = open(runtimefile_path, 'w')

   242

        runtimefile.write(svghmiservercode)

   243

        runtimefile.close()

   244

   245

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

   246

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

   247

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   248

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

   249

        hmitree_backup_file.close()

   250

   251

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

   252

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

   253

                #         ^

   254

                # note the double zero after "runtime_", 

   255

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

   256

   257

    def GlobalInstances(self):

   258

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

   259

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

   260

   261

   262

   263

def Register_SVGHMI_UI_for_HMI_tree_updates(ref):

   264

    global on_hmitree_update

   265

    def HMITreeUpdate(_hmi_tree_root):

   266

        obj = ref()

   267

        if obj is not None:

   268

            obj.HMITreeUpdate(_hmi_tree_root)

   269

   270

    on_hmitree_update = HMITreeUpdate

   271

   272

   273

class SVGHMIEditor(ConfTreeNodeEditor):

   274

    CONFNODEEDITOR_TABS = [

   275

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

   276

   277

    def CreateSVGHMI_UI(self, parent):

   278

        global hmi_tree_root

   279

   280

        if hmi_tree_root is None:

   281

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

   282

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

   283

            if os.path.exists(hmitree_backup_path):

   284

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   285

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

   286

   287

        ret = SVGHMI_UI(parent, Register_SVGHMI_UI_for_HMI_tree_updates)

   288

   289

        on_hmitree_update(hmi_tree_root)

   290

   291

        return ret

   292

   293

class SVGHMI(object):

   294

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

   295

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

   296

      <xsd:element name="SVGHMI">

   297

        <xsd:complexType>

   298

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

   299

          <xsd:attribute name="OnStop" type="xsd:string" use="optional" default="echo 'please close chromium window at {url}'"/>

   301

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

   302

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

   303

            <xsd:simpleType>

   304

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

   305

                    <xsd:minInclusive value="2"/>

   306

                    <xsd:maxInclusive value="600"/>

   307

                </xsd:restriction>

   308

            </xsd:simpleType>

   309

          </xsd:attribute>

   310

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

   311

            <xsd:simpleType>

   312

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

   313

                    <xsd:minInclusive value="2"/>

   314

                    <xsd:maxInclusive value="60"/>

   315

                </xsd:restriction>

   316

            </xsd:simpleType>

   317

          </xsd:attribute>

   318

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

   319

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

   320

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

   321

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

   322

            <xsd:simpleType>

   323

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

   324

                    <xsd:minInclusive value="1"/>

   325

                    <xsd:maxInclusive value="1024"/>

   326

                </xsd:restriction>

   327

            </xsd:simpleType>

   328

          </xsd:attribute>

   329

        </xsd:complexType>

   330

      </xsd:element>

   331

    </xsd:schema>

   332

    """

   333

   334

    EditorType = SVGHMIEditor

   335

   336

    ConfNodeMethods = [

   337

        {

   338

            "bitmap":    "ImportSVG",

   339

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

   340

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

   341

            "method":   "_ImportSVG"

   342

        },

   343

        {

   344

            "bitmap":    "EditSVG",

   345

            "name":    _("Inkscape"),

   346

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

   347

            "method":   "_StartInkscape"

   348

        },

   349

        {

   350

            "bitmap":    "OpenPOT",

   351

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

   352

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

   353

            "method":   "_OpenPOT"

   354

        },

   355

        {

   356

            "bitmap":    "EditPO",

   357

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

   358

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

   359

            "method":   "_EditPO"

   360

        },

   361

        {

   362

            "bitmap":    "AddFont",

   363

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

   364

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

   365

            "method":   "_AddFont"

   366

        },

   367

        {

   368

            "bitmap":    "DelFont",

   369

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

   370

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

   371

            "method":   "_DelFont"

   372

        },

   373

    ]

   374

   375

    def _getSVGpath(self, project_path=None):

   376

        if project_path is None:

   377

            project_path = self.CTNPath()

   378

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

   379

   380

    def _getPOTpath(self, project_path=None):

   381

        if project_path is None:

   382

            project_path = self.CTNPath()

   383

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

   384

   385

    def OnCTNSave(self, from_project_path=None):

   386

        if from_project_path is not None:

   387

            shutil.copyfile(self._getSVGpath(from_project_path),

   388

                            self._getSVGpath())

   389

            shutil.copyfile(self._getPOTpath(from_project_path),

   390

                            self._getPOTpath())

   391

            # XXX TODO copy .PO files

   392

        return True

   393

   394

    def GetSVGGeometry(self):

   395

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

   396

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

   397

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

   398

   399

        inkpath = get_inkscape_path()

   400

   401

        if inkpath is None:

   402

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

   403

   404

        svgpath = self._getSVGpath()

   405

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

   406

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

   407

                                                     no_stdout=True,

   408

                                                     no_stderr=True).spin()

   409

        if status != 0:

   410

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

   411

   412

        res = []

   413

        for line in result.split():

   414

            strippedline = line.strip()

   415

            attrs = dict(

   416

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

   417

   418

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

   419

   420

        self.ProgressEnd("inkscape")

   421

        return res

   422

   423

    def GetHMITree(self):

   424

        global hmi_tree_root

   425

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

   426

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

   427

        self.ProgressEnd("hmitree")

   428

        return res

   429

   430

    def GetTranslations(self, _context, msgs):

   431

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

   432

        messages = EtreeToMessages(msgs)

   433

   434

        if len(messages) == 0:

   435

            self.ProgressEnd("i18n")

   436

            return

   437

   438

        SaveCatalog(self._getPOTpath(), messages)

   439

   440

        translations = ReadTranslations(self.CTNPath())

   441

   442

        langs,translated_messages = MatchTranslations(translations, messages, 

   443

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

   444

   445

        ret = TranslationToEtree(langs,translated_messages)

   446

   447

        self.ProgressEnd("i18n")

   448

   449

        return ret

   450

   451

    def GetFontsFiles(self):

   452

        project_path = self.CTNPath()

   453

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

   454

        if os.path.isdir(fontdir):

   455

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

   456

        return []

   457

   458

    def GetFonts(self, _context):

   459

        css_parts = []

   460

   461

        for fontfile in self.GetFontsFiles():

   462

            if os.path.isfile(fontfile):

   463

                css_parts.append(GetCSSFontFaceFromFontFile(fontfile))

   464

   465

        return "".join(css_parts)

   466

   467

    times_msgs = {}

   468

    indent = 1

   469

    def ProgressStart(self, k, m):

   470

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

   471

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

   472

        self.indent = self.indent + 1

   473

   474

    def ProgressEnd(self, k):

   475

        t = time.time()

   476

        oldt, m = self.times_msgs[k]

   477

        self.indent = self.indent - 1

   478

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

   479

   480

    def get_SVGHMI_options(self):

   481

        view_name = self.BaseParams.getName()

   482

        port = self.GetParamsAttributes("SVGHMI.Port")["value"]

   483

        interface = self.GetParamsAttributes("SVGHMI.Interface")["value"]

   484

        path = self.GetParamsAttributes("SVGHMI.Path")["value"].format(name=view_name)

   485

        if path and path[0]=='/':

   486

            path = path[1:]

   487

        enable_watchdog = self.GetParamsAttributes("SVGHMI.EnableWatchdog")["value"]

   488

        url="http://"+interface+("" if port==80 else (":"+str(port))