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

    39

base_folder = os.path.split(

    40

    os.path.dirname(os.path.realpath(__file__)))[0]

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

    48

# Parameters to be monkey patched in beremiz customizations

    49

BACNET_VENDOR_ID = 9999

    50

BACNET_VENDOR_NAME = "Beremiz.org"

    51

BACNET_DEVICE_MODEL_NAME = "Beremiz PLC"

    52

    53

#

    54

#

    55

#

    56

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

    57

#

    58

#

    59

#

    60

    61

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

    62

#       The objects are instead instantiated from class FinalCTNClass

    63

#       FinalCTNClass inherits from: - ConfigTreeNode

    64

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

    65

# class _BacnetSlavePlug:

    66

    67

    68

class RootClass(object):

    69

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

    70

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

    71

      <xsd:element name="BACnetServerNode">

    72

        <xsd:complexType>

    73

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

    74

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

    75

            <xsd:simpleType>

    76

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

    77

                    <xsd:minInclusive value="0"/>

    78

                    <xsd:maxInclusive value="65535"/>

    79

                </xsd:restriction>

    80

            </xsd:simpleType>

    81

          </xsd:attribute>

    82

          <xsd:attribute name="BACnet_Communication_Control_Password"

    83

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

    84

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

    85

            <xsd:simpleType>

    86

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

    87

                    <xsd:minInclusive value="0"/>

    88

                    <xsd:maxInclusive value="4194302"/>

    89

                </xsd:restriction>

    90

            </xsd:simpleType>

    91

          </xsd:attribute>

    92

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

    93

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

    94

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

    95

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

    96

        </xsd:complexType>

    97

      </xsd:element>

    98

    </xsd:schema>

    99

    """

   100

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

   101

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

   102

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

   103

    #       valid ID becomes 4194302

   104

   105

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

   106

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

   107

    #    will be instantiated by the ConfigTreeNode class.

   108

    #    This BacnetSlaveEditorPlug object can be accessed from _BacnetSlavePlug as

   109

    #    'self._View'

   110

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

   111

    #

   112

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

   113

    #       The objects are instead instantiated from class FinalCTNClass

   114

    #       FinalCTNClass inherits from: - ConfigTreeNode

   115

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

   116

    #

   117

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

   118

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

   119

    #       as a FinalCTNClass)

   120

    EditorType = BacnetSlaveEditorPlug

   121

   122

    # The following classes follow the model/viewer design pattern

   123

    #

   124

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

   125

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

   126

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

   127

    #

   128

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

   129

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

   130

    #                                                         in the editing panel. It is destoryed whenever

   131

    #                                                         the user closes the corresponding tab in the

   132

    #                                                         editing panel, and a new object is created when

   133

    #                                                         the editor is re-opened.

   134

    #

   135

    # _BacnetSlavePlug contains:  AV_ObjTable, ...

   136

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

   137

    #                              and are therefore stored to a file)

   138

    #

   139

    # _BacnetSlavePlug contains:  AV_VarEditor, ...

   140

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

   141

    #                              corresponding mode parameters)

   142

    #

   143

    #  Logic:

   144

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

   145

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

   146

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

   147

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

   148

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

   149

    #

   150

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

   151

    #  data that is displayed and edited in the Grid.

   152

   153

    ConfNodeMethods = [

   154

        {"bitmap": "ExportSlave",

   155

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

   156

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

   157

         "method": "_ExportBacnetSlave"},

   158

    ]

   159

   160

    def __init__(self):

   161

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

   162

        #   in this BACnet server.

   163

        self.ObjTablesData = {}

   164

   165

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

   166

        #   Each entry/row will be a dictionary

   167

        #     Each dictionary will contain all entries/data

   168

        # for one row in the grid.

   169

   170

        self.ObjTablesData["AV_Obj"] = []

   171

        self.ObjTablesData["AO_Obj"] = []

   172

        self.ObjTablesData["AI_Obj"] = []

   173

        self.ObjTablesData["BV_Obj"] = []

   174

        self.ObjTablesData["BO_Obj"] = []

   175

        self.ObjTablesData["BI_Obj"] = []

   176

        self.ObjTablesData["MSV_Obj"] = []

   177

        self.ObjTablesData["MSO_Obj"] = []

   178

        self.ObjTablesData["MSI_Obj"] = []

   179

   180

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

   181

   182

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

   183

        # We would like to save the parameters the user configures

   184

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

   185

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

   186

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

   187

        # Yes, I know this is kind of a

   188

        # hack.

   189

   190

        filepath = self.GetFileName()

   191

        if os.path.isfile(filepath):

   192

            self.LoadFromFile(filepath)

   193

   194

        self.ObjTables = {}

   195

        self.ObjTables["AV_Obj"] = ObjectTable(

   196

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

   197

        self.ObjTables["AO_Obj"] = ObjectTable(

   198

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

   199

        self.ObjTables["AI_Obj"] = ObjectTable(

   200

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

   201

        self.ObjTables["BV_Obj"] = ObjectTable(

   202

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

   203

        self.ObjTables["BO_Obj"] = ObjectTable(

   204

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

   205

        self.ObjTables["BI_Obj"] = ObjectTable(

   206

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

   207

        self.ObjTables["MSV_Obj"] = ObjectTable(

   208

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

   209

        self.ObjTables["MSO_Obj"] = ObjectTable(

   210

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

   211

        self.ObjTables["MSI_Obj"] = ObjectTable(

   212

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

   213

   214

    #

   215

    # Functions to be called by CTNClass #

   216

    #

   217

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

   218

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

   219

    # _BacnetSlavePlug class derives.

   220

   221

    def GetCurrentNodeName(self):

   222

        return self.CTNName()

   223

   224

    def GetFileName(self):

   225

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

   226

   227

    def OnCTNSave(self, from_project_path=None):

   228

        return self.SaveToFile(self.GetFileName())

   229

   230

    def CTNTestModified(self):

   231

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

   232

        #                     This is handled by the ConfigTreeNode class

   233

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

   234

        #                      Objects are instead created from FinalCTNClass, which derives from

   235

        #                      _BacnetSlavePlug and ConfigTreeNode. This means that we can exceptionally

   236

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

   237

        # ConfigTreeNode).

   238

        result = self.ChangesToSave \

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

            or self.ObjTables["MSI_Obj"].ChangesToSave

   248

        return result

   249

   250

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

   251

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

   252

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

   253

        # ConfigTreeNode._OpenView(self, name, onlyopened)

   254

        # print self._View

   255

        # if self._View is not None:

   256

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

   257

        # return self._View

   258

   259

    def GetVariableLocationTree(self):

   260

        current_location = self.GetCurrentLocation()

   261

        # see comment in CTNGenerate_C regarding identical line of code!

   262

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

   263

   264

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

   265

        #     OBJECT_ANALOG_INPUT       =  0,

   266

        #     OBJECT_ANALOG_OUTPUT      =  1,

   267

        #     OBJECT_ANALOG_VALUE       =  2,

   268

        #     OBJECT_BINARY_INPUT       =  3,

   269

        #     OBJECT_BINARY_OUTPUT      =  4,

   270

        #     OBJECT_BINARY_VALUE       =  5,

   271

        #     OBJECT_MULTI_STATE_INPUT  = 13,

   272

        #     OBJECT_MULTI_STATE_OUTPUT = 14,

   273

        #     OBJECT_MULTI_STATE_VALUE  = 19,

   274

        #

   275

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

   276

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

   277

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

   278

        #

   279

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

   280

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

   281

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

   282

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

   283

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

   284

        #  etc..

   285

        #

   286

        #   Value objects will be mapped onto %M

   287

        #   Input objects will be mapped onto %I

   288

        #  Output objects will be mapped onto %Q

   289

   290

        BACnetEntries = []

   291

        BACnetEntries.append(self.GetSlaveLocationTree(

   292

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

   293

        BACnetEntries.append(self.GetSlaveLocationTree(

   294

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

   295

        BACnetEntries.append(self.GetSlaveLocationTree(

   296

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

   297

        BACnetEntries.append(self.GetSlaveLocationTree(

   298

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

   299

        BACnetEntries.append(self.GetSlaveLocationTree(

   300

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

   301

        BACnetEntries.append(self.GetSlaveLocationTree(

   302

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

   303

        BACnetEntries.append(self.GetSlaveLocationTree(

   304

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

   305

        BACnetEntries.append(self.GetSlaveLocationTree(

   306

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

   307

        BACnetEntries.append(self.GetSlaveLocationTree(

   308

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

   309

   310

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

   311

                "type": LOCATION_CONFNODE,

   312

                "location": locstr + ".x",

   313

                "children": BACnetEntries}

   314

   315

    #

   316

    # Helper functions/methods #

   317

    #

   318

    # a helper function to GetVariableLocationTree()

   319

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

   320

        BACnetObjectEntries = []

   321

        for xx_ObjProp in ObjTablesData:

   322

            BACnetObjectEntries.append({

   323

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

   324

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

   325

                "size": size_in_bits,  # 1 or 16

   326

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

   327

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

   328

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

   329

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

   330

                "children": []})

   331

   332

        return {"name": name,

   333

                "type": LOCATION_CONFNODE,

   334

                "location": location_str + ".x",

   335

                "children": BACnetObjectEntries}

   336

   337

    # Returns a dictionary with:

   338

    #      keys: names  of BACnet objects

   339

    #     value: number of BACnet objects using this same name

   340

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

   341

    def GetObjectNamesCount(self):

   342

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

   343

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

   344

        ObjectNames = []

   345

        ObjectNames.extend(

   346

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

   347

        ObjectNames.extend(

   348

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

   349

        ObjectNames.extend(

   350

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

   351

        ObjectNames.extend(

   352

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

   353

        ObjectNames.extend(

   354

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

   355

        ObjectNames.extend(

   356

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

   357

        ObjectNames.extend(

   358

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

   359

        ObjectNames.extend(

   360

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

   361

        ObjectNames.extend(

   362

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

   363

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

   364

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

   365

        return dict(Counter(ObjectNames))

   366

   367

    # Check whether the current configuration contains BACnet objects configured

   368

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

   369

    def HasDuplicateObjectNames(self):

   370

        ObjectNamesCount = self.GetObjectNamesCount()

   371

        for ObjName in ObjectNamesCount:

   372

            if ObjectNamesCount[ObjName] > 1:

   373

                return True

   374

        return False

   375

   376

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

   377

    # (returns True or False)

   378

    def HasDuplicateObjectIDs(self):

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

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

   386

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

   387

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

   388

        return res

   389

   390

    #

   391

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

   392

    #

   393

    def SaveToFile(self, filepath):

   394

        # Save node data in file

   395

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

   396

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

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

        try:

   404

            fd = open(filepath,   "w")

   405

            pickle.dump(self.ObjTablesData, fd)

   406

            fd.close()

   407

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

   408

            # need saving

   409

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

   410

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

   411

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

   412

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

   413

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

   414

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

   415

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

   416

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

   417

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

   418

            return True

   419

        except:

   420

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

   421

   422

    def LoadFromFile(self, filepath):

   423

        # Load the data that is saved in SaveToFile()

   424

        try:

   425

            fd = open(filepath,   "r")

   426

            self.ObjTablesData = pickle.load(fd)

   427

            fd.close()

   428

            return True

   429

        except:

   430

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

   431

   432

    def _ExportBacnetSlave(self):

   433

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

   434

                               _("Choose a file"),

   435

                               os.path.expanduser("~"),

   436

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

   437

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

   438

                               wx.SAVE | wx.OVERWRITE_PROMPT)

   439

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

   440

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

   441

            result = False

   442

            if result:

   443

                self.GetCTRoot().logger.write_error(

   444

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

   445

        dialog.Destroy()

   446

   447

    def GenerateEDEFile(self, filename):

   448

        template_file_dir = os.path.join(

   449

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

   450

   451

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

   452

        # It will be an XML parser object created by

   453

        # GenerateParserFromXSDstring(self.XSD).CreateRoot()

   454

        BACnet_Device_ID = self.BACnetServerNode.getBACnet_Device_ID()

   455

   456

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

   457

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

   458

        # of the Beremiz project itself.

   459

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

   460

        ProjProp = {}

   461

        FileProp = {}

   462

   463

        # this should be an object of class ProjectController

   464

        CTN_Root = self.GetCTRoot()

   465

   466

        # this should be an object capable of parsing

   467

        # PLCopen XML files. The parser is created automatically

   468

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

   469

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

   470

        # See the file plcopen/plcopen.py

   471

        Project = CTN_Root.Project

   472

        if Project is not None:

   473

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

   474

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

   475

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

   476

                ProjProp = Project.getcontentHeader()

   477

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

   478

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

   479

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

   480

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

   481

                FileProp = Project.getfileHeader()

   482

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

   483

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

   484

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

   485

   486

        ProjName = ""

   487

        if "projectName" in ProjProp:

   488

            ProjName = ProjProp["projectName"]

   489

        ProjAuthor = ""

   490

        if "companyName" in FileProp:

   491

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

   492

        if "authorName" in ProjProp:

   493

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

   494

   495

        projdata_dict = {}

   496

        projdata_dict["Project Name"] = ProjName

   497

        projdata_dict["Project Author"] = ProjAuthor

   498

        projdata_dict["Current Time"] = datetime.now().strftime(

   499

            '%Y-%m-%d %H:%M:%S')

   500

        projdata_dict["EDE file version"] = self.ObjTablesData[

   501

            "EDEfile_parm"]["next_EDE_file_version"]

   502

   503

        # Next time we generate an EDE file, use another version!

   504

        self.ObjTablesData["EDEfile_parm"]["next_EDE_file_version"] += 1

   505