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

base_folder = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]

    42

base_folder = os.path.join(base_folder, "..")

    43

BacnetPath  = os.path.join(base_folder, "BACnet")

    44

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

    45

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

    46

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

    47

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

    48

    49

# Parameters to be monkey patched in beremiz customizations

    50

BACNET_VENDOR_ID = 9999

    51

BACNET_VENDOR_NAME = "Beremiz.org"

    52

BACNET_DEVICE_MODEL_NAME = "Beremiz PLC"

    53

    54

    55

# Max String Size of BACnet Paramaters

    56

BACNET_PARAM_STRING_SIZE = 64

    57

    58

#

    59

#

    60

#

    61

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

    62

#

    63

#

    64

#

    65

    66

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

    67

#       The objects are instead instantiated from class FinalCTNClass

    68

#       FinalCTNClass inherits from: - ConfigTreeNode

    69

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

    70

# class _BacnetSlavePlug:

    71

    72

    73

class RootClass(object):

    74

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

    75

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

    76

      <xsd:element name="BACnetServerNode">

    77

        <xsd:complexType>

    78

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

    79

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

    80

            <xsd:simpleType>

    81

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

    82

                    <xsd:minInclusive value="0"/>

    83

                    <xsd:maxInclusive value="65535"/>

    84

                </xsd:restriction>

    85

            </xsd:simpleType>

    86

          </xsd:attribute>

    87

          <xsd:attribute name="BACnet_Communication_Control_Password"

    88

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

    89

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

    90

            <xsd:simpleType>

    91

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

    92

                    <xsd:minInclusive value="0"/>

    93

                    <xsd:maxInclusive value="4194302"/>

    94

                </xsd:restriction>

    95

            </xsd:simpleType>

    96

          </xsd:attribute>

    97

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

    98

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

    99

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

   100

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

   101

        </xsd:complexType>

   102

      </xsd:element>

   103

    </xsd:schema>

   104

    """

   105

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

   106

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

   107

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

   108

    #        <--- snip --->

   109

    #          <xsd:attribute name="Override_Parameters_Saved_on_PLC" 

   110

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

   111

    #        <--- snip --->

   112

    #

   113

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

   114

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

   115

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

   116

    #       valid ID becomes 4194302

   117

   118

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

   119

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

   120

    #    will be instantiated by the ConfigTreeNode class.

   121

    #    This BacnetSlaveEditorPlug object can be accessed from _BacnetSlavePlug as

   122

    #    'self._View'

   123

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

   124

    #

   125

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

   126

    #       The objects are instead instantiated from class FinalCTNClass

   127

    #       FinalCTNClass inherits from: - ConfigTreeNode

   128

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

   129

    #

   130

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

   131

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

   132

    #       as a FinalCTNClass)

   133

    EditorType = BacnetSlaveEditorPlug

   134

   135

    # The following classes follow the model/viewer design pattern

   136

    #

   137

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

   138

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

   139

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

   140

    #

   141

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

   142

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

   143

    #                                                         in the editing panel. It is destoryed whenever

   144

    #                                                         the user closes the corresponding tab in the

   145

    #                                                         editing panel, and a new object is created when

   146

    #                                                         the editor is re-opened.

   147

    #

   148

    # _BacnetSlavePlug contains:  AV_ObjTable, ...

   149

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

   150

    #                              and are therefore stored to a file)

   151

    #

   152

    # _BacnetSlavePlug contains:  AV_VarEditor, ...

   153

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

   154

    #                              corresponding mode parameters)

   155

    #

   156

    #  Logic:

   157

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

   158

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

   159

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

   160

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

   161

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

   162

    #

   163

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

   164

    #  data that is displayed and edited in the Grid.

   165

   166

    ConfNodeMethods = [

   167

        {"bitmap": "ExportSlave",

   168

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

   169

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

   170

         "method": "_ExportBacnetSlave"},

   171

    ]

   172

   173

    def __init__(self):

   174

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

   175

        #   in this BACnet server.

   176

        self.ObjTablesData = {}

   177

   178

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

   179

        #   Each entry/row will be a dictionary

   180

        #     Each dictionary will contain all entries/data

   181

        # for one row in the grid.

   182

   183

        self.ObjTablesData["AV_Obj"] = []

   184

        self.ObjTablesData["AO_Obj"] = []

   185

        self.ObjTablesData["AI_Obj"] = []

   186

        self.ObjTablesData["BV_Obj"] = []

   187

        self.ObjTablesData["BO_Obj"] = []

   188

        self.ObjTablesData["BI_Obj"] = []

   189

        self.ObjTablesData["MSV_Obj"] = []

   190

        self.ObjTablesData["MSO_Obj"] = []

   191

        self.ObjTablesData["MSI_Obj"] = []

   192

   193

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

   194

   195

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

   196

        # We would like to save the parameters the user configures

   197

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

   198

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

   199

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

   200

        # Yes, I know this is kind of a

   201

        # hack.

   202

   203

        filepath = self.GetFileName()

   204

        if os.path.isfile(filepath):

   205

            self.LoadFromFile(filepath)

   206

   207

        self.ObjTables = {}

   208

        self.ObjTables["AV_Obj"] = ObjectTable(

   209

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

   210

        self.ObjTables["AO_Obj"] = ObjectTable(

   211

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

   212

        self.ObjTables["AI_Obj"] = ObjectTable(

   213

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

   214

        self.ObjTables["BV_Obj"] = ObjectTable(

   215

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

   216

        self.ObjTables["BO_Obj"] = ObjectTable(

   217

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

   218

        self.ObjTables["BI_Obj"] = ObjectTable(

   219

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

   220

        self.ObjTables["MSV_Obj"] = ObjectTable(

   221

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

   222

        self.ObjTables["MSO_Obj"] = ObjectTable(

   223

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

   224

        self.ObjTables["MSI_Obj"] = ObjectTable(

   225

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

   226

   227

    #

   228

    # Functions to be called by CTNClass #

   229

    #

   230

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

   231

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

   232

    # _BacnetSlavePlug class derives.

   233

   234

    def GetCurrentNodeName(self):

   235

        return self.CTNName()

   236

   237

    def GetFileName(self):

   238

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

   239

   240

    def OnCTNSave(self, from_project_path=None):

   241

        return self.SaveToFile(self.GetFileName())

   242

   243

    def CTNTestModified(self):

   244

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

   245

        #                     This is handled by the ConfigTreeNode class

   246

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

   247

        #                      Objects are instead created from FinalCTNClass, which derives from

   248

        #                      _BacnetSlavePlug and ConfigTreeNode. This means that we can exceptionally

   249

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

   250

        # ConfigTreeNode).

   251

        result = self.ChangesToSave \

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

            or self.ObjTables["MSI_Obj"].ChangesToSave

   261

        return result

   262

   263

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

   264

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

   265

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

   266

        # ConfigTreeNode._OpenView(self, name, onlyopened)

   267

        # print self._View

   268

        # if self._View is not None:

   269

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

   270

        # return self._View

   271

   272

    def GetVariableLocationTree(self):

   273

        current_location = self.GetCurrentLocation()

   274

        # see comment in CTNGenerate_C regarding identical line of code!

   275

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

   276

   277

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

   278

        #     OBJECT_ANALOG_INPUT       =  0,

   279

        #     OBJECT_ANALOG_OUTPUT      =  1,

   280

        #     OBJECT_ANALOG_VALUE       =  2,

   281

        #     OBJECT_BINARY_INPUT       =  3,

   282

        #     OBJECT_BINARY_OUTPUT      =  4,

   283

        #     OBJECT_BINARY_VALUE       =  5,

   284

        #     OBJECT_MULTI_STATE_INPUT  = 13,

   285

        #     OBJECT_MULTI_STATE_OUTPUT = 14,

   286

        #     OBJECT_MULTI_STATE_VALUE  = 19,

   287

        #

   288

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

   289

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

   290

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

   291

        #

   292

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

   293

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

   294

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

   295

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

   296

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

   297

        #  etc..

   298

        #

   299

        #   Value objects will be mapped onto %M

   300

        #   Input objects will be mapped onto %I

   301

        #  Output objects will be mapped onto %Q

   302

   303

        BACnetEntries = []

   304

        BACnetEntries.append(self.GetSlaveLocationTree(

   305

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

   306

        BACnetEntries.append(self.GetSlaveLocationTree(

   307

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

   308

        BACnetEntries.append(self.GetSlaveLocationTree(

   309

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

   310

        BACnetEntries.append(self.GetSlaveLocationTree(

   311

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

   312

        BACnetEntries.append(self.GetSlaveLocationTree(

   313

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

   314

        BACnetEntries.append(self.GetSlaveLocationTree(

   315

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

   316

        BACnetEntries.append(self.GetSlaveLocationTree(

   317

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

   318

        BACnetEntries.append(self.GetSlaveLocationTree(

   319

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

   320

        BACnetEntries.append(self.GetSlaveLocationTree(

   321

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

   322

   323

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

   324

                "type": LOCATION_CONFNODE,

   325

                "location": locstr + ".x",

   326

                "children": BACnetEntries}

   327

   328

    #

   329

    # Helper functions/methods #

   330

    #

   331

    # a helper function to GetVariableLocationTree()

   332

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

   333

        BACnetObjectEntries = []

   334

        for xx_ObjProp in ObjTablesData:

   335

            BACnetObjectEntries.append({

   336

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

   337

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

   338

                "size": size_in_bits,  # 1 or 16

   339

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

   340

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

   341

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

   342

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

   343

                "children": []})

   344

   345

        return {"name": name,

   346

                "type": LOCATION_CONFNODE,

   347

                "location": location_str + ".x",

   348

                "children": BACnetObjectEntries}

   349

   350

    # Returns a dictionary with:

   351

    #      keys: names  of BACnet objects

   352

    #     value: number of BACnet objects using this same name

   353

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

   354

    def GetObjectNamesCount(self):

   355

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

   356

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

   357

        ObjectNames = []

   358

        ObjectNames.extend(

   359

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

   360

        ObjectNames.extend(

   361

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

   362

        ObjectNames.extend(

   363

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

   364

        ObjectNames.extend(

   365

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

   366

        ObjectNames.extend(

   367

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

   368

        ObjectNames.extend(

   369

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

   370

        ObjectNames.extend(

   371

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

   372

        ObjectNames.extend(

   373

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

   374

        ObjectNames.extend(

   375

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

   376

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

   377

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

   378

        return dict(Counter(ObjectNames))

   379

   380

    # Check whether the current configuration contains BACnet objects configured

   381

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

   382

    def HasDuplicateObjectNames(self):

   383

        ObjectNamesCount = self.GetObjectNamesCount()

   384

        for ObjName in ObjectNamesCount:

   385

            if ObjectNamesCount[ObjName] > 1:

   386

                return True

   387

        return False

   388

   389

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

   390

    # (returns True or False)

   391

    def HasDuplicateObjectIDs(self):

   392

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

   393

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

   394

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

   395

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

   396

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

   397

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

   398

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

   399

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

   400

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

   401

        return res

   402

   403

    #

   404

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

   405

    #

   406

    def SaveToFile(self, filepath):

   407

        # Save node data in file

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

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

   415

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

   416

        try:

   417

            fd = open(filepath,   "w")

   418

            pickle.dump(self.ObjTablesData, fd)

   419

            fd.close()

   420

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

   421

            # need saving

   422

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

   423

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

   424

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

   425

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

   426

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

   427

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

   428

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

   429

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

   430

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

   431

            return True

   432

        except Exception:

   433

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

   434

   435

    def LoadFromFile(self, filepath):

   436

        # Load the data that is saved in SaveToFile()

   437

        try:

   438

            fd = open(filepath,   "r")

   439

            self.ObjTablesData = pickle.load(fd)

   440

            fd.close()

   441

            return True

   442

        except Exception:

   443

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

   444

   445

    def _ExportBacnetSlave(self):

   446

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

   447

                               _("Choose a file"),

   448

                               os.path.expanduser("~"),

   449

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

   450

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

   451

                               wx.SAVE | wx.OVERWRITE_PROMPT)

   452

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

   453

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

   454

            result = False

   455

            if result:

   456

                self.GetCTRoot().logger.write_error(

   457

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

   458

        dialog.Destroy()

   459

   460

    def GenerateEDEFile(self, filename):

   461

        template_file_dir = os.path.join(

   462

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

   463

   464

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

   465

        # It will be an XML parser object created by

   466

        # GenerateParserFromXSDstring(self.XSD).CreateRoot()

   467

        BACnet_Device_ID = self.BACnetServerNode.getBACnet_Device_ID()

   468

   469

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

   470

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

   471

        # of the Beremiz project itself.

   472

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

   473

        ProjProp = {}

   474

        FileProp = {}

   475

   476

        # this should be an object of class ProjectController

   477

        CTN_Root = self.GetCTRoot()

   478

   479

        # this should be an object capable of parsing

   480

        # PLCopen XML files. The parser is created automatically

   481

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

   482

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

   483

        # See the file plcopen/plcopen.py

   484

        Project = CTN_Root.Project

   485

        if Project is not None:

   486

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

   487

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

   488

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

   489

                ProjProp = Project.getcontentHeader()

   490

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

   491

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

   492

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

   493

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

   494

                FileProp = Project.getfileHeader()

   495

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

   496

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

   497

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

   498

   499

        ProjName = ""

   500

        if "projectName" in ProjProp:

   501

            ProjName = ProjProp["projectName"]

   502

        ProjAuthor = ""

   503

        if "companyName" in FileProp:

   504

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