1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard.

     6

# This files implements the bacnet plugin for Beremiz, adding BACnet server support.

     7

#

     8

# Copyright (c) 2017 Mario de Sousa (msousa@fe.up.pt)

     9

#

    10

# This program is free software: you can redistribute it and/or modify

    11

# it under the terms of the GNU General Public License as published by

    12

# the Free Software Foundation, either version 2 of the License, or

    13

# (at your option) any later version.

    14

#

    15

# This program is distributed in the hope that it will be useful,

    16

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    17

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    18

# GNU General Public License for more details.

    19

#

    20

# You should have received a copy of the GNU General Public License

    21

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

    22

#

    23

# This code is made available on the understanding that it will not be

    24

# used in safety-critical situations without a full and competent review.

    25

    26

from __future__ import absolute_import

    27

    28

import os

    29

from collections import Counter

    30

from datetime import datetime

    31

import pickle

    32

    33

import wx

    34

    35

from bacnet.BacnetSlaveEditor import *

    36

from bacnet.BacnetSlaveEditor import ObjectProperties

    37

from PLCControler import LOCATION_CONFNODE, LOCATION_VAR_MEMORY

    38

from ConfigTreeNode import ConfigTreeNode

    39

import util.paths as paths

    40

    41

BacnetPath = paths.ThirdPartyPath("BACnet")

    42

BacnetLibraryPath = os.path.join(BacnetPath, "lib")

    43

BacnetIncludePath = os.path.join(BacnetPath, "include")

    44

BacnetIncludePortPath = os.path.join(BacnetPath, "ports")

    45

BacnetIncludePortPath = os.path.join(BacnetIncludePortPath, "linux")

    46

    47

# Parameters to be monkey patched in beremiz customizations

    48

BACNET_VENDOR_ID = 9999

    49

BACNET_VENDOR_NAME = "Beremiz.org"

    50

BACNET_DEVICE_MODEL_NAME = "Beremiz PLC"

    51

    52

    53

# Max String Size of BACnet Paramaters

    54

BACNET_PARAM_STRING_SIZE = 64

    55

    56

#

    57

#

    58

#

    59

# S L A V E    D E V I C E              #

    60

#

    61

#

    62

#

    63

    64

# NOTE: Objects of class _BacnetSlavePlug are never instantiated directly.

    65

#       The objects are instead instantiated from class FinalCTNClass

    66

#       FinalCTNClass inherits from: - ConfigTreeNode

    67

#                                    - The tree node plug (in our case _BacnetSlavePlug)

    68

# class _BacnetSlavePlug:

    69

    70

    71

class RootClass(object):

    72

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

    73

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

    74

      <xsd:element name="BACnetServerNode">

    75

        <xsd:complexType>

    76

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

    77

          <xsd:attribute name="UDP_Port_Number"                           use="optional" default="47808">

    78

            <xsd:simpleType>

    79

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

    80

                    <xsd:minInclusive value="0"/>

    81

                    <xsd:maxInclusive value="65535"/>

    82

                </xsd:restriction>

    83

            </xsd:simpleType>

    84

          </xsd:attribute>

    85

          <xsd:attribute name="BACnet_Communication_Control_Password"

    86

                                                       type="xsd:string"  use="optional" default="Malba Tahan"/>

    87

          <xsd:attribute name="BACnet_Device_ID"                          use="optional" default="0">

    88

            <xsd:simpleType>

    89

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

    90

                    <xsd:minInclusive value="0"/>

    91

                    <xsd:maxInclusive value="4194302"/>

    92

                </xsd:restriction>

    93

            </xsd:simpleType>

    94

          </xsd:attribute>

    95

          <xsd:attribute name="BACnet_Device_Name"        type="xsd:string"  use="optional" default="Beremiz device 0"/>

    96

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

    97

          <xsd:attribute name="BACnet_Device_Description" type="xsd:string"  use="optional" default="Beremiz device 0"/>

    98

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

    99

        </xsd:complexType>

   100

      </xsd:element>

   101

    </xsd:schema>

   102

    """

   103

    # NOTE; Add the following code/declaration to the aboce XSD in order to activate the

   104

    #          Override_Parameters_Saved_on_PLC   flag (currenty not in use as it requires further

   105

    #          analysis how the user would interpret this user interface option.

   106

    #        <--- snip --->

   107

    #          <xsd:attribute name="Override_Parameters_Saved_on_PLC" 

   108

    #                                                   type="xsd:boolean" use="optional" default="true"/>

   109

    #        <--- snip --->

   110

    #

   111

    # NOTE: BACnet device (object) IDs are 22 bits long (not counting the 10 bits for the type ID)

   112

    #       so the Device instance ID is limited from 0 to 22^2-1 = 4194303

   113

    #       However, 4194303 is reserved for special use (similar to NULL pointer), so last

   114

    #       valid ID becomes 4194302

   115

   116

    # The class/object that will render the graphical interface to edit the

   117

    #    BacnetSlavePlug's configuration parameters. The object of class BacnetSlaveEditorPlug

   118

    #    will be instantiated by the ConfigTreeNode class.

   119

    #    This BacnetSlaveEditorPlug object can be accessed from _BacnetSlavePlug as

   120

    #    'self._View'

   121

    #    See the following note to understand how this is possible!

   122

    #

   123

    # NOTE: Objects of class _BacnetSlavePlug are never instantiated directly.

   124

    #       The objects are instead instantiated from class FinalCTNClass

   125

    #       FinalCTNClass inherits from: - ConfigTreeNode

   126

    #                                    - The tree node plug (in our case _BacnetSlavePlug)

   127

    #

   128

    #       This means that objects of class _BacnetSlavePlug may safely access all the members

   129

    #       of classes ConfigTreeNode as well as FinalCTNClass (since they are always instantiated

   130

    #       as a FinalCTNClass)

   131

    EditorType = BacnetSlaveEditorPlug

   132

   133

    # The following classes follow the model/viewer design pattern

   134

    #

   135

    # _BacnetSlavePlug       - contains the model (i.e. configuration parameters)

   136

    # BacnetSlaveEditorPlug  - contains the viewer (and editor, so it includes the 'controller' part of the

   137

    #                                    design pattern which in this case is not separated from the viewer)

   138

    #

   139

    # The _BacnetSlavePlug      object is 'permanent', i.e. it exists as long as the beremiz project is open

   140

    # The BacnetSlaveEditorPlug object is 'transient', i.e. it exists only while the editor is visible/open

   141

    #                                                         in the editing panel. It is destoryed whenever

   142

    #                                                         the user closes the corresponding tab in the

   143

    #                                                         editing panel, and a new object is created when

   144

    #                                                         the editor is re-opened.

   145

    #

   146

    # _BacnetSlavePlug contains:  AV_ObjTable, ...

   147

    #                             (these are the objects that actually store the config parameters or 'model'

   148

    #                              and are therefore stored to a file)

   149

    #

   150

    # _BacnetSlavePlug contains:  AV_VarEditor, ...

   151

    #                             (these are the objects that implement a grid table to edit/view the

   152

    #                              corresponding mode parameters)

   153

    #

   154

    #  Logic:

   155

    #    - The xx_VarEditor classes inherit from wx.grid.Grid

   156

    #    - The xx_ObjTable  classes inherit from wx.grid.PyGridTableBase

   157

    #  To be more precise, the inheritance tree is actually:

   158

    #    xx_VarEditor -> ObjectGrid -> CustomGrid   -> wx.grid.Grid

   159

    #    xx_ObjTable  -> ObjectTable -> CustomTable -> wx.grid.PyGridTableBase)

   160

    #

   161

    #  Note that wx.grid.Grid is prepared to work with wx.grid.PyGridTableBase as the container of

   162

    #  data that is displayed and edited in the Grid.

   163

   164

    ConfNodeMethods = [

   165

        {"bitmap": "ExportSlave",

   166

         "name": _("Export slave"),

   167

         "tooltip": _("Export BACnet slave to EDE file"),

   168

         "method": "_ExportBacnetSlave"},

   169

    ]

   170

   171

    def __init__(self):

   172

        # Initialize the dictionary that stores the current configuration for the Analog/Digital/MultiValued Variables

   173

        #   in this BACnet server.

   174

        self.ObjTablesData = {}

   175

   176

        # Each list will contain an entry for each row in the xxxxVar grid!!

   177

        #   Each entry/row will be a dictionary

   178

        #     Each dictionary will contain all entries/data

   179

        # for one row in the grid.

   180

   181

        self.ObjTablesData["AV_Obj"] = []

   182

        self.ObjTablesData["AO_Obj"] = []

   183

        self.ObjTablesData["AI_Obj"] = []

   184

        self.ObjTablesData["BV_Obj"] = []

   185

        self.ObjTablesData["BO_Obj"] = []

   186

        self.ObjTablesData["BI_Obj"] = []

   187

        self.ObjTablesData["MSV_Obj"] = []

   188

        self.ObjTablesData["MSO_Obj"] = []

   189

        self.ObjTablesData["MSI_Obj"] = []

   190

   191

        self.ObjTablesData["EDEfile_parm"] = {"next_EDE_file_version": 1}

   192

   193

        # EDE files inlcude extra parameters (ex. file version)

   194

        # We would like to save the parameters the user configures

   195

        # so they are available the next time the user opens the project.

   196

        # Since this plugin is only storing the ObjTablesData[] dict

   197

        # to file, we add that info to this dictionary too.

   198

        # Yes, I know this is kind of a

   199

        # hack.

   200

   201

        filepath = self.GetFileName()

   202

        if os.path.isfile(filepath):

   203

            self.LoadFromFile(filepath)

   204

   205

        self.ObjTables = {}

   206

        self.ObjTables["AV_Obj"] = ObjectTable(

   207

            self, self.ObjTablesData["AV_Obj"],  AVObject)

   208

        self.ObjTables["AO_Obj"] = ObjectTable(

   209

            self, self.ObjTablesData["AO_Obj"],  AOObject)

   210

        self.ObjTables["AI_Obj"] = ObjectTable(

   211

            self, self.ObjTablesData["AI_Obj"],  AIObject)

   212

        self.ObjTables["BV_Obj"] = ObjectTable(

   213

            self, self.ObjTablesData["BV_Obj"],  BVObject)

   214

        self.ObjTables["BO_Obj"] = ObjectTable(

   215

            self, self.ObjTablesData["BO_Obj"],  BOObject)

   216

        self.ObjTables["BI_Obj"] = ObjectTable(

   217

            self, self.ObjTablesData["BI_Obj"],  BIObject)

   218

        self.ObjTables["MSV_Obj"] = ObjectTable(

   219

            self, self.ObjTablesData["MSV_Obj"], MSVObject)

   220

        self.ObjTables["MSO_Obj"] = ObjectTable(

   221

            self, self.ObjTablesData["MSO_Obj"], MSOObject)

   222

        self.ObjTables["MSI_Obj"] = ObjectTable(

   223

            self, self.ObjTablesData["MSI_Obj"], MSIObject)

   224

   225

    #

   226

    # Functions to be called by CTNClass #

   227

    #

   228

    # The following functions would be somewhat equvalent to virtual functions/methods in C++ classes

   229

    # They will be called by the base class (CTNClass) from which this

   230

    # _BacnetSlavePlug class derives.

   231

   232

    def GetCurrentNodeName(self):

   233

        return self.CTNName()

   234

   235

    def GetFileName(self):

   236

        return os.path.join(self.CTNPath(), 'bacnet_slave')

   237

   238

    def OnCTNSave(self, from_project_path=None):

   239

        return self.SaveToFile(self.GetFileName())

   240

   241

    def CTNTestModified(self):

   242

        # self.ChangesToSave: Check whether any of the parameters, defined in the XSD above, were changed.

   243

        #                     This is handled by the ConfigTreeNode class

   244

        #                     (Remember that no objects are ever instantiated from _BacnetSlavePlug.

   245

        #                      Objects are instead created from FinalCTNClass, which derives from

   246

        #                      _BacnetSlavePlug and ConfigTreeNode. This means that we can exceptionally

   247

        # consider that all objects of type _BacnetSlavePlug will also be a

   248

        # ConfigTreeNode).

   249

        result = self.ChangesToSave \

   250

            or self.ObjTables["AV_Obj"].ChangesToSave \

   251

            or self.ObjTables["AO_Obj"].ChangesToSave \

   252

            or self.ObjTables["AI_Obj"].ChangesToSave \

   253

            or self.ObjTables["BV_Obj"].ChangesToSave \

   254

            or self.ObjTables["BO_Obj"].ChangesToSave \

   255

            or self.ObjTables["BI_Obj"].ChangesToSave \

   256

            or self.ObjTables["MSV_Obj"].ChangesToSave \

   257

            or self.ObjTables["MSO_Obj"].ChangesToSave \

   258

            or self.ObjTables["MSI_Obj"].ChangesToSave

   259

        return result

   260

   261

    # Currently not needed. Override _OpenView() in case we need to do some special stuff whenever the editor is opened!

   262

    # def _OpenView(self, name=None, onlyopened=False):

   263

        # print "_BacnetSlavePlug._OpenView() Called!!!"

   264

        # ConfigTreeNode._OpenView(self, name, onlyopened)

   265

        # print self._View

   266

        # if self._View is not None:

   267

        #     self._View.SetBusId(self.GetCurrentLocation())

   268

        # return self._View

   269

   270

    def GetVariableLocationTree(self):

   271

        current_location = self.GetCurrentLocation()

   272

        # see comment in CTNGenerate_C regarding identical line of code!

   273

        locstr = ".".join(map(str, current_location))

   274

   275

        # IDs used by BACnet to identify object types/class.

   276

        #     OBJECT_ANALOG_INPUT       =  0,

   277

        #     OBJECT_ANALOG_OUTPUT      =  1,

   278

        #     OBJECT_ANALOG_VALUE       =  2,

   279

        #     OBJECT_BINARY_INPUT       =  3,

   280

        #     OBJECT_BINARY_OUTPUT      =  4,

   281

        #     OBJECT_BINARY_VALUE       =  5,

   282

        #     OBJECT_MULTI_STATE_INPUT  = 13,

   283

        #     OBJECT_MULTI_STATE_OUTPUT = 14,

   284

        #     OBJECT_MULTI_STATE_VALUE  = 19,

   285

        #

   286

        #  Since Binary Value, Analog Value, etc. objects may use the same

   287

        # object ID (since they have distinct class IDs), we must also distinguish them in some way in

   288

        # the %MX0.3.4 IEC 61131-3 syntax.

   289

        #

   290

        # For this reason we add the BACnet class identifier to the %MX0.5.3 location.

   291

        # For example, for a BACnet plugin in location '0' of the Beremiz configuration tree,

   292

        #  all      Binary Values will be mapped onto: %MX0.5.xxx    (xxx is object ID)

   293

        #  all Multi State Values will be mapped onto: %MB0.19.xxx   (xxx is object ID)

   294

        #  all      Analog Values will be mapped onto: %MD0.2.xxx    (xxx is object ID)

   295

        #  etc..

   296

        #

   297

        #   Value objects will be mapped onto %M

   298

        #   Input objects will be mapped onto %I

   299

        #  Output objects will be mapped onto %Q

   300

   301

        BACnetEntries = []

   302

        BACnetEntries.append(self.GetSlaveLocationTree(

   303

            self.ObjTablesData["AV_Obj"], 32, 'REAL', 'D', locstr + '.2', 'Analog Values'))

   304

        BACnetEntries.append(self.GetSlaveLocationTree(

   305

            self.ObjTablesData["AO_Obj"], 32, 'REAL', 'D', locstr + '.1', 'Analog Outputs'))

   306

        BACnetEntries.append(self.GetSlaveLocationTree(

   307

            self.ObjTablesData["AI_Obj"], 32, 'REAL', 'D', locstr + '.0', 'Analog Inputs'))

   308

        BACnetEntries.append(self.GetSlaveLocationTree(

   309

            self.ObjTablesData["BV_Obj"],  1, 'BOOL', 'X', locstr + '.5', 'Binary Values'))

   310

        BACnetEntries.append(self.GetSlaveLocationTree(

   311

            self.ObjTablesData["BO_Obj"],  1, 'BOOL', 'X', locstr + '.4', 'Binary Outputs'))

   312

        BACnetEntries.append(self.GetSlaveLocationTree(

   313

            self.ObjTablesData["BI_Obj"],  1, 'BOOL', 'X', locstr + '.3', 'Binary Inputs'))

   314

        BACnetEntries.append(self.GetSlaveLocationTree(

   315

            self.ObjTablesData["MSV_Obj"],  8, 'BYTE', 'B', locstr + '.19', 'Multi State Values'))

   316

        BACnetEntries.append(self.GetSlaveLocationTree(

   317

            self.ObjTablesData["MSO_Obj"],  8, 'BYTE', 'B', locstr + '.14', 'Multi State Outputs'))

   318

        BACnetEntries.append(self.GetSlaveLocationTree(

   319

            self.ObjTablesData["MSI_Obj"],  8, 'BYTE', 'B', locstr + '.13', 'Multi State Inputs'))

   320

   321

        return {"name": self.BaseParams.getName(),

   322

                "type": LOCATION_CONFNODE,

   323

                "location": locstr + ".x",

   324

                "children": BACnetEntries}

   325

   326

    #

   327

    # Helper functions/methods #

   328

    #

   329

    # a helper function to GetVariableLocationTree()

   330

    def GetSlaveLocationTree(self, ObjTablesData, size_in_bits, IECdatatype, location_size, location_str, name):

   331

        BACnetObjectEntries = []

   332

        for xx_ObjProp in ObjTablesData:

   333

            BACnetObjectEntries.append({

   334

                "name": str(xx_ObjProp["Object Identifier"]) + ': ' + xx_ObjProp["Object Name"],

   335

                "type": LOCATION_VAR_MEMORY,  # LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, or LOCATION_VAR_MEMORY

   336

                "size": size_in_bits,  # 1 or 16

   337

                "IEC_type": IECdatatype,  # 'BOOL', 'WORD', ...

   338

                "var_name": "var_name",  # seems to be ignored??

   339

                "location": location_size + location_str + "." + str(xx_ObjProp["Object Identifier"]),

   340

                "description": "description",  # seems to be ignored?

   341

                "children": []})

   342

   343

        return {"name": name,

   344

                "type": LOCATION_CONFNODE,

   345

                "location": location_str + ".x",

   346

                "children": BACnetObjectEntries}

   347

   348

    # Returns a dictionary with:

   349

    #      keys: names  of BACnet objects

   350

    #     value: number of BACnet objects using this same name

   351

    #            (values larger than 1 indicates an error as BACnet requires unique names)

   352

    def GetObjectNamesCount(self):

   353

        # The dictionary is built by first creating a list containing the names of _ALL_

   354

        # BACnet objects currently configured by the user (using the GUI)

   355

        ObjectNames = []

   356

        ObjectNames.extend(

   357

            self.ObjTables["AV_Obj"].GetAllValuesByName("Object Name"))

   358

        ObjectNames.extend(

   359

            self.ObjTables["AO_Obj"].GetAllValuesByName("Object Name"))

   360

        ObjectNames.extend(

   361

            self.ObjTables["AI_Obj"].GetAllValuesByName("Object Name"))

   362

        ObjectNames.extend(

   363

            self.ObjTables["BV_Obj"].GetAllValuesByName("Object Name"))

   364

        ObjectNames.extend(

   365

            self.ObjTables["BO_Obj"].GetAllValuesByName("Object Name"))

   366

        ObjectNames.extend(

   367

            self.ObjTables["BI_Obj"].GetAllValuesByName("Object Name"))

   368

        ObjectNames.extend(

   369

            self.ObjTables["MSV_Obj"].GetAllValuesByName("Object Name"))

   370

        ObjectNames.extend(

   371

            self.ObjTables["MSO_Obj"].GetAllValuesByName("Object Name"))

   372

        ObjectNames.extend(

   373

            self.ObjTables["MSI_Obj"].GetAllValuesByName("Object Name"))

   374

        # This list is then transformed into a collections.Counter class

   375

        # Which is then transformed into a dictionary using dict()

   376

        return dict(Counter(ObjectNames))

   377

   378

    # Check whether the current configuration contains BACnet objects configured

   379

    # with the same identical object name  (returns True or False)

   380

    def HasDuplicateObjectNames(self):

   381

        ObjectNamesCount = self.GetObjectNamesCount()

   382

        for ObjName in ObjectNamesCount:

   383

            if ObjectNamesCount[ObjName] > 1:

   384

                return True

   385

        return False

   386

   387

    # Check whether any object ID is used more than once (not valid in BACnet)

   388

    # (returns True or False)

   389

    def HasDuplicateObjectIDs(self):

   390

        res = self.ObjTables["AV_Obj"].HasDuplicateObjectIDs()

   391

        res = res or self.ObjTables["AO_Obj"].HasDuplicateObjectIDs()

   392

        res = res or self.ObjTables["AI_Obj"].HasDuplicateObjectIDs()

   393

        res = res or self.ObjTables["BV_Obj"].HasDuplicateObjectIDs()

   394

        res = res or self.ObjTables["BO_Obj"].HasDuplicateObjectIDs()

   395

        res = res or self.ObjTables["BI_Obj"].HasDuplicateObjectIDs()

   396

        res = res or self.ObjTables["MSV_Obj"].HasDuplicateObjectIDs()

   397

        res = res or self.ObjTables["MSO_Obj"].HasDuplicateObjectIDs()

   398

        res = res or self.ObjTables["MSI_Obj"].HasDuplicateObjectIDs()

   399

        return res

   400

   401

    #

   402

    # Methods related to files (saving/loading/exporting) #

   403

    #

   404

    def SaveToFile(self, filepath):

   405

        # Save node data in file

   406

        # The configuration data declared in the XSD string will be saved by the ConfigTreeNode class,

   407

        # so we only need to save the data that is stored in ObjTablesData objects

   408

        # Note that we do not store the ObjTables objects. ObjTables is of a class that

   409

        # contains more stuff we do not need to store. Actually it is a bad idea to store

   410

        # this extra stuff (as we would make the files we generate dependent on the actual

   411

        # version of the wx library we are using!!! Remember that ObjTables evetually

   412

        # derives/inherits from wx.grid.PyGridTableBase). Another reason not to store the whole

   413

        # object is because it is not pickable (i.e. pickle.dump() cannot handle it)!!

   414

        try:

   415

            fd = open(filepath,   "w")

   416

            pickle.dump(self.ObjTablesData, fd)

   417

            fd.close()

   418

            # On successfull save, reset flags to indicate no more changes that

   419

            # need saving

   420

            self.ObjTables["AV_Obj"].ChangesToSave = False

   421

            self.ObjTables["AO_Obj"].ChangesToSave = False

   422

            self.ObjTables["AI_Obj"].ChangesToSave = False

   423

            self.ObjTables["BV_Obj"].ChangesToSave = False

   424

            self.ObjTables["BO_Obj"].ChangesToSave = False

   425

            self.ObjTables["BI_Obj"].ChangesToSave = False

   426

            self.ObjTables["MSV_Obj"].ChangesToSave = False

   427

            self.ObjTables["MSO_Obj"].ChangesToSave = False

   428

            self.ObjTables["MSI_Obj"].ChangesToSave = False

   429

            return True

   430

        except Exception:

   431

            return _("Unable to save to file \"%s\"!") % filepath

   432

   433

    def LoadFromFile(self, filepath):

   434

        # Load the data that is saved in SaveToFile()

   435

        try:

   436

            fd = open(filepath,   "r")

   437

            self.ObjTablesData = pickle.load(fd)

   438

            fd.close()

   439

            return True

   440

        except Exception:

   441

            return _("Unable to load file \"%s\"!") % filepath

   442

   443

    def _ExportBacnetSlave(self):

   444

        dialog = wx.FileDialog(self.GetCTRoot().AppFrame,

   445

                               _("Choose a file"),

   446

                               os.path.expanduser("~"),

   447

                               "%s_EDE.csv" % self.CTNName(),

   448

                               _("EDE files (*_EDE.csv)|*_EDE.csv|All files|*.*"),

   449

                               wx.SAVE | wx.OVERWRITE_PROMPT)

   450

        if dialog.ShowModal() == wx.ID_OK:

   451

            result = self.GenerateEDEFile(dialog.GetPath())

   452

            result = False

   453

            if result:

   454

                self.GetCTRoot().logger.write_error(

   455

                    _("Error: Export slave failed\n"))

   456

        dialog.Destroy()

   457

   458

    def GenerateEDEFile(self, filename):

   459

        template_file_dir = os.path.join(

   460

            os.path.split(__file__)[0], "ede_files")

   461

   462

        # The BACnetServerNode attribute is added dynamically by ConfigTreeNode._AddParamsMembers()

   463

        # It will be an XML parser object created by

   464

        # GenerateParserFromXSDstring(self.XSD).CreateRoot()

   465

        BACnet_Device_ID = self.BACnetServerNode.getBACnet_Device_ID()

   466

   467

        # The EDE file contains a header that includes general project data (name, author, ...)

   468

        # Instead of asking the user for this data, we get it from the configuration

   469

        # of the Beremiz project itself.

   470

        # We ask the root Config Tree Node for the data...

   471

        ProjProp = {}

   472

        FileProp = {}

   473

   474

        # this should be an object of class ProjectController

   475

        CTN_Root = self.GetCTRoot()

   476

   477

        # this should be an object capable of parsing

   478

        # PLCopen XML files. The parser is created automatically

   479

        # (i.e. using GenerateParserFromXSD() from xmlclass module)

   480

        # using the PLCopen XSD file defining the format of the XML.

   481

        # See the file plcopen/plcopen.py

   482

        Project = CTN_Root.Project

   483

        if Project is not None:

   484

            # getcontentHeader() and getfileHeader() are functions that are conditionally defined in

   485

            # plcopn/plcopen.py    We cannot rely on their existance

   486

            if getattr(Project, "getcontentHeader", None) is not None:

   487

                ProjProp = Project.getcontentHeader()

   488

                # getcontentHeader() returns a dictionary. Available keys are:

   489

                # "projectName", "projectVersion", "modificationDateTime",

   490

                # "organization", "authorName", "language", "pageSize", "scaling"

   491

            if getattr(Project, "getfileHeader", None) is not None:

   492

                FileProp = Project.getfileHeader()

   493

                # getfileHeader() returns a dictionary. Available keys are:

   494

                # "companyName", "companyURL", "productName", "productVersion",

   495

                # "productRelease", "creationDateTime", "contentDescription"

   496

   497

        ProjName = ""

   498

        if "projectName" in ProjProp:

   499

            ProjName = ProjProp["projectName"]

   500

        ProjAuthor = ""

   501

        if "companyName" in FileProp:

   502

            ProjAuthor += "(" + FileProp["companyName"] + ")"

   503

        if "authorName" in ProjProp:

   504

            ProjAuthor = ProjProp["authorName"] + " " + ProjAuthor

   505