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

    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.GridTableBase

   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.GridTableBase)

   160

    #

   161

    #  Note that wx.grid.Grid is prepared to work with wx.grid.GridTableBase 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.GridTableBase). 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