1

#!/usr/bin/env python

     2

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

     3

     4

#This file is part of CanFestival, a library implementing CanOpen Stack. 

     5

#

     6

#Copyright (C): Edouard TISSERANT, Francis DUPIN and Laurent BESSARD

     7

#

     8

#See COPYING file for copyrights details.

     9

#

    10

#This library is free software; you can redistribute it and/or

    11

#modify it under the terms of the GNU Lesser General Public

    12

#License as published by the Free Software Foundation; either

    13

#version 2.1 of the License, or (at your option) any later version.

    14

#

    15

#This library 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 GNU

    18

#Lesser General Public License for more details.

    19

#

    20

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

    21

#License along with this library; if not, write to the Free Software

    22

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    23

    24

    25

import node

    26

from node import nosub, var, array, rec, plurivar, pluriarray, plurirec

    27

try:

    28

    set

    29

except NameError:

    30

    from sets import Set as set

    31

from types import *

    32

from time import *

    33

import os,re

    34

    35

# Regular expression for finding index section names

    36

index_model = re.compile('([0-9A-F]{1,4}$)')

    37

# Regular expression for finding subindex section names

    38

subindex_model = re.compile('([0-9A-F]{1,4})SUB([0-9A-F]{1,2}$)')

    39

# Regular expression for finding index section names

    40

index_objectlinks_model = re.compile('([0-9A-F]{1,4}OBJECTLINKS$)')

    41

    42

# Regular expression for finding NodeXPresent keynames

    43

nodepresent_model = re.compile('NODE([0-9]{1,3})PRESENT$')

    44

# Regular expression for finding NodeXName keynames

    45

nodename_model = re.compile('NODE([0-9]{1,3})NAME$')

    46

# Regular expression for finding NodeXDCFName keynames

    47

nodedcfname_model = re.compile('NODE([0-9]{1,3})DCFNAME$')

    48

    49

# Dictionary for quickly translate boolean into integer value

    50

BOOL_TRANSLATE = {True : "1", False : "0"}

    51

    52

# Dictionary for quickly translate eds access value into canfestival access value

    53

ACCESS_TRANSLATE = {"RO" : "ro", "WO" : "wo", "RW" : "rw", "RWR" : "rw", "RWW" : "rw", "CONST" : "ro"}

    54

    55

# Function for verifying data values

    56

is_integer = lambda x: type(x) in (IntType, LongType)

    57

is_string = lambda x: type(x) in (StringType, UnicodeType)

    58

is_boolean = lambda x: x in (0, 1)

    59

    60

# Define checking of value for each attribute

    61

ENTRY_ATTRIBUTES = {"SUBNUMBER" : is_integer, 

    62

                    "PARAMETERNAME" : is_string, 

    63

                    "OBJECTTYPE" : lambda x: x in (2, 7, 8, 9), 

    64

                    "DATATYPE" : is_integer, 

    65

                    "LOWLIMIT" : is_integer, 

    66

                    "HIGHLIMIT" : is_integer,

    67

                    "ACCESSTYPE" : lambda x: x.upper() in ACCESS_TRANSLATE.keys(),

    68

                    "DEFAULTVALUE" : lambda x: True, 

    69

                    "PDOMAPPING" : is_boolean,

    70

                    "OBJFLAGS" : is_integer, 

    71

                    "PARAMETERVALUE" : lambda x: True,

    72

                    "UPLOADFILE" : is_string,

    73

                    "DOWNLOADFILE" : is_string}

    74

    75

# Define entry parameters by entry ObjectType number

    76

ENTRY_TYPES = {2 : {"name" : " DOMAIN",

    77

                    "require" : ["PARAMETERNAME", "OBJECTTYPE"],

    78

                    "optional" : ["DATATYPE", "ACCESSTYPE", "DEFAULTVALUE", "OBJFLAGS"]},

    79

               7 : {"name" : " VAR",

    80

                    "require" : ["PARAMETERNAME", "DATATYPE", "ACCESSTYPE"],

    81

                    "optional" : ["OBJECTTYPE", "DEFAULTVALUE", "PDOMAPPING", "LOWLIMIT", "HIGHLIMIT", "OBJFLAGS", "PARAMETERVALUE"]},

    82

               8 : {"name" : "n ARRAY",

    83

                    "require" : ["PARAMETERNAME", "OBJECTTYPE", "SUBNUMBER"],

    84

                    "optional" : ["OBJFLAGS"]},

    85

               9 : {"name" : " RECORD",

    86

                    "require" : ["PARAMETERNAME", "OBJECTTYPE", "SUBNUMBER"],

    87

                    "optional" : ["OBJFLAGS"]}}

    88

    89

    90

# Function that search into Node Mappings the informations about an index or a subindex

    91

# and return the default value

    92

def GetDefaultValue(Node, index, subIndex = None):

    93

    infos = Node.GetEntryInfos(index)

    94

    if infos["struct"] & node.OD_MultipleSubindexes:

    95

        # First case entry is a record

    96

        if infos["struct"] & node.OD_IdenticalSubindexes:

    97

            subentry_infos = Node.GetSubentryInfos(index, 1)

    98

        # Second case entry is an array

    99

        else:

   100

            subentry_infos = Node.GetSubentryInfos(index, subIndex)

   101

        # If a default value is defined for this subindex, returns it

   102

        if "default" in subentry_infos:

   103

            return subentry_infos["default"]

   104

        # If not, returns the default value for the subindex type

   105

        else:

   106

            return Node.GetTypeDefaultValue(subentry_infos["type"])

   107

    # Third case entry is a var

   108

    else:

   109

        subentry_infos = Node.GetSubentryInfos(index, 0)

   110

        # If a default value is defined for this subindex, returns it

   111

        if "default" in subentry_infos:

   112

            return subentry_infos["default"]

   113

        # If not, returns the default value for the subindex type

   114

        else:

   115

            return Node.GetTypeDefaultValue(subentry_infos["type"])

   116

    return None

   117

   118

   119

#-------------------------------------------------------------------------------

   120

#                               Parse file

   121

#-------------------------------------------------------------------------------

   122

   123

   124

# List of section names that are not index and subindex and that we can meet in

   125

# an EDS file

   126

SECTION_KEYNAMES = ["FILEINFO", "DEVICEINFO", "DUMMYUSAGE", "COMMENTS", 

   127

                    "MANDATORYOBJECTS", "OPTIONALOBJECTS", "MANUFACTUREROBJECTS",

   128

                    "STANDARDDATATYPES", "SUPPORTEDMODULES"]

   129

   130

   131

# Function that extract sections from a file and returns a dictionary of the informations

   132

def ExtractSections(file):

   133

    return [(blocktuple[0],                # EntryName : Assignements dict

   134

             blocktuple[-1].splitlines())  # all the lines

   135

             for blocktuple in [           # Split the eds files into

   136

             block.split("]", 1)              # (EntryName,Assignements) tuple

   137

             for block in                  # for each blocks staring with '['

   138

             ("\n"+file).split("\n[")]

   139

             if blocktuple[0].isalnum()]   # if EntryName exists

   140

   141

   142

# Function that parse an CPJ file and returns a dictionary of the informations

   143

def ParseCPJFile(filepath):

   144

    networks = []

   145

    # Read file text

   146

    cpj_file = open(filepath,'r').read()

   147

    sections = ExtractSections(cpj_file)

   148

    # Parse assignments for each section

   149

    for section_name, assignments in sections:

   150

   151

        # Verify that section name is TOPOLOGY 

   152

        if section_name.upper() in "TOPOLOGY":

   153

   154

            # Reset values for topology

   155

            topology = {"Name" : "", "Nodes" : {}}

   156

   157

            for assignment in assignments:

   158

                # Escape any comment

   159

                if assignment.startswith(";"):

   160

                    pass

   161

                # Verify that line is a valid assignment

   162

                elif assignment.find('=') > 0:

   163

                    # Split assignment into the two values keyname and value

   164

                    keyname, value = assignment.split("=", 1)

   165

   166

                    # keyname must be immediately followed by the "=" sign, so we

   167

                    # verify that there is no whitespace into keyname

   168

                    if keyname.isalnum():

   169

                        # value can be preceded and followed by whitespaces, so we escape them

   170

                        value = value.strip()

   171

   172

                        # First case, value starts with "0x" or "-0x", then it's an hexadecimal value

   173

                        if value.startswith("0x") or value.startswith("-0x"):

   174

                            try:

   175

                                computed_value = int(value, 16)

   176

                            except:

   177

                                raise SyntaxError, _("\"%s\" is not a valid value for attribute \"%s\" of section \"[%s]\"")%(value, keyname, section_name)

   178

                        elif value.isdigit() or value.startswith("-") and value[1:].isdigit():

   179

                            # Second case, value is a number and starts with "0" or "-0", then it's an octal value

   180

                            if value.startswith("0") or value.startswith("-0"):

   181

                                computed_value = int(value, 8)

   182

                            # Third case, value is a number and don't start with "0", then it's a decimal value

   183

                            else:

   184

                                computed_value = int(value)

   185

                        # In any other case, we keep string value

   186

                        else:

   187

                            computed_value = value

   188

   189

                        # Search if the section name match any cpj expression

   190

                        nodepresent_result = nodepresent_model.match(keyname.upper())

   191

                        nodename_result = nodename_model.match(keyname.upper())

   192

                        nodedcfname_result = nodedcfname_model.match(keyname.upper())

   193

   194

                        if keyname.upper() == "NETNAME":

   195

                            if not is_string(computed_value):

   196

                                raise SyntaxError, _("Invalid value \"%s\" for keyname \"%s\" of section \"[%s]\"")%(value, keyname, section_name)

   197

                            topology["Name"] = computed_value

   198

                        elif keyname.upper() == "NODES":

   199

                            if not is_integer(computed_value):

   200

                                raise SyntaxError, _("Invalid value \"%s\" for keyname \"%s\" of section \"[%s]\"")%(value, keyname, section_name)

   201

                            topology["Number"] = computed_value

   202

                        elif keyname.upper() == "EDSBASENAME":

   203

                            if not is_string(computed_value):

   204

                                raise SyntaxError, _("Invalid value \"%s\" for keyname \"%s\" of section \"[%s]\"")%(value, keyname, section_name)

   205

                            topology["Path"] = computed_value

   206

                        elif nodepresent_result:

   207

                            if not is_boolean(computed_value):

   208

                                raise SyntaxError, _("Invalid value \"%s\" for keyname \"%s\" of section \"[%s]\"")%(value, keyname, section_name)

   209

                            nodeid = int(nodepresent_result.groups()[0])

   210

                            if nodeid not in topology["Nodes"].keys():

   211

                                topology["Nodes"][nodeid] = {}

   212

                            topology["Nodes"][nodeid]["Present"] = computed_value

   213

                        elif nodename_result:

   214

                            if not is_string(value):

   215

                                raise SyntaxError, _("Invalid value \"%s\" for keyname \"%s\" of section \"[%s]\"")%(value, keyname, section_name)

   216

                            nodeid = int(nodename_result.groups()[0])

   217

                            if nodeid not in topology["Nodes"].keys():

   218

                                topology["Nodes"][nodeid] = {}

   219

                            topology["Nodes"][nodeid]["Name"] = computed_value

   220

                        elif nodedcfname_result:

   221

                            if not is_string(computed_value):

   222

                                raise SyntaxError, _("Invalid value \"%s\" for keyname \"%s\" of section \"[%s]\"")%(value, keyname, section_name)

   223

                            nodeid = int(nodedcfname_result.groups()[0])

   224

                            if nodeid not in topology["Nodes"].keys():

   225

                                topology["Nodes"][nodeid] = {}

   226

                            topology["Nodes"][nodeid]["DCFName"] = computed_value

   227

                        else:

   228

                            raise SyntaxError, _("Keyname \"%s\" not recognised for section \"[%s]\"")%(keyname, section_name)

   229

   230

                # All lines that are not empty and are neither a comment neither not a valid assignment

   231

                elif assignment.strip() != "":

   232

                    raise SyntaxError, _("\"%s\" is not a valid CPJ line")%assignment.strip()

   233

   234

            if "Number" not in topology.keys():

   235

                raise SyntaxError, _("\"Nodes\" keyname in \"[%s]\" section is missing")%section_name

   236

   237

            if topology["Number"] != len(topology["Nodes"]):

   238

                raise SyntaxError, _("\"Nodes\" value not corresponding to number of nodes defined")

   239

   240

            for nodeid, node in topology["Nodes"].items():

   241

                if "Present" not in node.keys():

   242

                    raise SyntaxError, _("\"Node%dPresent\" keyname in \"[%s]\" section is missing")%(nodeid, section_name)

   243

   244

            networks.append(topology)

   245

   246

        # In other case, there is a syntax problem into CPJ file

   247

        else:

   248

            raise SyntaxError, _("Section \"[%s]\" is unrecognized")%section_name

   249

   250

    return networks

   251

   252

# Function that parse an EDS file and returns a dictionary of the informations

   253

def ParseEDSFile(filepath):

   254

    eds_dict = {}

   255

    # Read file text

   256

    eds_file = open(filepath,'r').read()

   257

    sections = ExtractSections(eds_file)

   258

   259

    # Parse assignments for each section

   260

    for section_name, assignments in sections:

   261

        # Reset values of entry

   262

        values = {}

   263

   264

        # Search if the section name match an index or subindex expression

   265

        index_result = index_model.match(section_name.upper())

   266

        subindex_result = subindex_model.match(section_name.upper())

   267

        index_objectlinks_result = index_objectlinks_model.match(section_name.upper())

   268

   269

        # Compilation of the EDS information dictionary

   270

   271

        is_entry = False

   272

        # First case, section name is in SECTION_KEYNAMES 

   273

        if section_name.upper() in SECTION_KEYNAMES:

   274

            # Verify that entry is not already defined

   275

            if section_name.upper() not in eds_dict:

   276

                eds_dict[section_name.upper()] = values

   277

            else:

   278

                raise SyntaxError, _("\"[%s]\" section is defined two times")%section_name

   279

        # Second case, section name is an index name 

   280

        elif index_result:

   281

            # Extract index number

   282

            index = int(index_result.groups()[0], 16)

   283

            # If index hasn't been referenced before, we add an entry into the dictionary

   284

            if index not in eds_dict:

   285

                eds_dict[index] = values

   286

                eds_dict[index]["subindexes"] = {}

   287

            elif eds_dict[index].keys() == ["subindexes"]:

   288

                values["subindexes"] = eds_dict[index]["subindexes"]

   289

                eds_dict[index] = values

   290

            else:

   291

                raise SyntaxError, _("\"[%s]\" section is defined two times")%section_name

   292

            is_entry = True

   293

        # Third case, section name is a subindex name 

   294

        elif subindex_result:

   295

            # Extract index and subindex number

   296

            index, subindex = [int(value, 16) for value in subindex_result.groups()]

   297

            # If index hasn't been referenced before, we add an entry into the dictionary

   298

            # that will be updated later

   299

            if index not in eds_dict:

   300

                eds_dict[index] = {"subindexes" : {}}

   301

            if subindex not in eds_dict[index]["subindexes"]:

   302

                eds_dict[index]["subindexes"][subindex] = values

   303

            else:

   304

                raise SyntaxError, _("\"[%s]\" section is defined two times")%section_name

   305

            is_entry = True

   306

        # Third case, section name is a subindex name 

   307

        elif index_objectlinks_result:

   308

            pass

   309

        # In any other case, there is a syntax problem into EDS file

   310

        else:

   311

            raise SyntaxError, _("Section \"[%s]\" is unrecognized")%section_name

   312

   313

        for assignment in assignments:

   314

            # Escape any comment

   315

            if assignment.startswith(";"):

   316

                pass

   317

            # Verify that line is a valid assignment

   318

            elif assignment.find('=') > 0:

   319

                # Split assignment into the two values keyname and value

   320

                keyname, value = assignment.split("=", 1)

   321

   322

                # keyname must be immediately followed by the "=" sign, so we

   323

                # verify that there is no whitespace into keyname

   324

                if keyname.isalnum():

   325

                    # value can be preceded and followed by whitespaces, so we escape them

   326

                    value = value.strip().replace(" ", "")

   327

                    # First case, value starts with "$NODEID", then it's a formula

   328

                    if value.upper().startswith("$NODEID"):

   329

                        try:

   330

                            test = int(value.upper().replace("$NODEID+", ""), 16)

   331

                            computed_value = "\"%s\""%value

   332

                        except:

   333

                            raise SyntaxError, _("\"%s\" is not a valid formula for attribute \"%s\" of section \"[%s]\"")%(value, keyname, section_name)

   334

                    # Second case, value starts with "0x", then it's an hexadecimal value

   335

                    elif value.startswith("0x") or value.startswith("-0x"):

   336

                        try:

   337

                            computed_value = int(value, 16)

   338

                        except:

   339

                            raise SyntaxError, _("\"%s\" is not a valid value for attribute \"%s\" of section \"[%s]\"")%(value, keyname, section_name)

   340

                    elif value.isdigit() or value.startswith("-") and value[1:].isdigit():

   341

                        # Third case, value is a number and starts with "0", then it's an octal value

   342

                        if value.startswith("0") or value.startswith("-0"):

   343

                            computed_value = int(value, 8)

   344

                        # Forth case, value is a number and don't start with "0", then it's a decimal value

   345

                        else:

   346

                            computed_value = int(value)

   347

                    # In any other case, we keep string value

   348

                    else:

   349

                        computed_value = value

   350

   351

                    # Add value to values dictionary

   352

                    if computed_value != "":

   353

                        # If entry is an index or a subindex

   354

                        if is_entry:

   355

                            # Verify that keyname is a possible attribute

   356

                            if keyname.upper() not in ENTRY_ATTRIBUTES:

   357

                                raise SyntaxError, _("Keyname \"%s\" not recognised for section \"[%s]\"")%(keyname, section_name)

   358

                            # Verify that value is valid

   359

                            elif not ENTRY_ATTRIBUTES[keyname.upper()](computed_value):

   360

                                raise SyntaxError, _("Invalid value \"%s\" for keyname \"%s\" of section \"[%s]\"")%(value, keyname, section_name)

   361

                            else:

   362

                                values[keyname.upper()] = computed_value

   363

                        else:

   364

                            values[keyname.upper()] = computed_value

   365

            # All lines that are not empty and are neither a comment neither not a valid assignment

   366

            elif assignment.strip() != "":

   367

                raise SyntaxError, _("\"%s\" is not a valid EDS line")%assignment.strip()

   368

   369

        # If entry is an index or a subindex

   370

        if is_entry:

   371

            # Verify that entry has an ObjectType

   372

            values["OBJECTTYPE"] = values.get("OBJECTTYPE", 7)

   373

            # Extract parameters defined

   374

            keys = set(values.keys())

   375

            keys.discard("subindexes")

   376

            # Extract possible parameters and parameters required

   377

            possible = set(ENTRY_TYPES[values["OBJECTTYPE"]]["require"] + 

   378

                           ENTRY_TYPES[values["OBJECTTYPE"]]["optional"])

   379

            required = set(ENTRY_TYPES[values["OBJECTTYPE"]]["require"])

   380

            # Verify that parameters defined contains all the parameters required

   381

            if not keys.issuperset(required):

   382

                missing = required.difference(keys)._data.keys()

   383

                if len(missing) > 1:

   384

                    attributes = _("Attributes %s are")%_(", ").join(["\"%s\""%attribute for attribute in missing])

   385

                else:

   386

                    attributes = _("Attribute \"%s\" is")%missing[0]

   387

                raise SyntaxError, _("Error on section \"[%s]\":\n%s required for a %s entry")%(section_name, attributes, ENTRY_TYPES[values["OBJECTTYPE"]]["name"])

   388

            # Verify that parameters defined are all in the possible parameters

   389

            if not keys.issubset(possible):

   390

                unsupported = keys.difference(possible)._data.keys()

   391

                if len(unsupported) > 1:

   392

                    attributes = _("Attributes %s are")%_(", ").join(["\"%s\""%attribute for attribute in unsupported])

   393

                else:

   394

                    attributes = _("Attribute \"%s\" is")%unsupported[0]

   395

                raise SyntaxError, _("Error on section \"[%s]\":\n%s unsupported for a %s entry")%(section_name, attributes, ENTRY_TYPES[values["OBJECTTYPE"]]["name"])

   396

   397

            VerifyValue(values, section_name, "ParameterValue")

   398

            VerifyValue(values, section_name, "DefaultValue")

   399

   400

    return eds_dict

   401

   402

def VerifyValue(values, section_name, param):

   403

    if param.upper() in values:

   404

        try:

   405

            if values["DATATYPE"] in (0x09, 0x0A, 0x0B, 0x0F):

   406

                values[param.upper()] = str(values[param.upper()])

   407

            elif values["DATATYPE"] in (0x08, 0x11):

   408

                values[param.upper()] = float(values[param.upper()])

   409

            elif values["DATATYPE"] == 0x01:

   410

                values[param.upper()] = {0 : False, 1 : True}[values[param.upper()]]

   411

            else:

   412

                if not isinstance(values[param.upper()], (IntType, LongType)) and values[param.upper()].upper().find("$NODEID") == -1:

   413

                    raise

   414

        except:

   415

            raise SyntaxError, _("Error on section \"[%s]\":\n%s incompatible with DataType")%(section_name, param)

   416

   417

   418

# Function that write an EDS file after generate it's content

   419

def WriteFile(filepath, content):

   420

    # Open file in write mode

   421

    cfile = open(filepath,"w")

   422

    # Write content

   423

    cfile.write(content)

   424

    # Close file

   425

    cfile.close()

   426

   427

   428

# Function that generate the EDS file content for the current node in the manager

   429

def GenerateFileContent(Node, filepath):

   430

    # Dictionary of each index contents

   431

    indexContents = {}

   432

   433

    # Extract local time

   434

    current_time = localtime()

   435

    # Extract node informations

   436

    nodename = Node.GetNodeName()

   437

    nodeid = Node.GetNodeID()

   438

    nodetype = Node.GetNodeType() 

   439

    description = Node.GetNodeDescription()

   440

   441

    # Retreiving lists of indexes defined

   442

    entries = Node.GetIndexes()

   443

   444

    # Generate FileInfo section

   445

    fileContent = "[FileInfo]\n"

   446

    fileContent += "FileName=%s\n"%os.path.split(filepath)[-1]

   447

    fileContent += "FileVersion=1\n"

   448

    fileContent += "FileRevision=1\n"

   449

    fileContent += "EDSVersion=4.0\n"

   450

    fileContent += "Description=%s\n"%description

   451

    fileContent += "CreationTime=%s"%strftime("%I:%M", current_time)

   452

    # %p option of strftime seems not working, then generate AM/PM by hands

   453

    if strftime("%I", current_time) == strftime("%H", current_time):

   454

        fileContent += "AM\n"

   455

    else:

   456

        fileContent += "PM\n"

   457

    fileContent += "CreationDate=%s\n"%strftime("%m-%d-%Y", current_time)

   458

    fileContent += "CreatedBy=CANFestival\n"

   459

    fileContent += "ModificationTime=%s"%strftime("%I:%M", current_time)

   460

    # %p option of strftime seems not working, then generate AM/PM by hands

   461

    if strftime("%I", current_time) == strftime("%H", current_time):

   462

        fileContent += "AM\n"

   463

    else:

   464

        fileContent += "PM\n"

   465

    fileContent += "ModificationDate=%s\n"%strftime("%m-%d-%Y", current_time)

   466

    fileContent += "ModifiedBy=CANFestival\n"

   467

   468

    # Generate DeviceInfo section

   469

    fileContent += "\n[DeviceInfo]\n"

   470

    fileContent += "VendorName=CANFestival\n"

   471

    # Use information typed by user in Identity entry

   472

    fileContent += "VendorNumber=0x%8.8X\n"%Node.GetEntry(0x1018, 1)

   473

    fileContent += "ProductName=%s\n"%nodename

   474

    fileContent += "ProductNumber=0x%8.8X\n"%Node.GetEntry(0x1018, 2)

   475

    fileContent += "RevisionNumber=0x%8.8X\n"%Node.GetEntry(0x1018, 3)

   476

    # CANFestival support all baudrates as soon as driver choosen support them

   477

    fileContent += "BaudRate_10=1\n"

   478

    fileContent += "BaudRate_20=1\n"

   479

    fileContent += "BaudRate_50=1\n"

   480

    fileContent += "BaudRate_125=1\n"

   481

    fileContent += "BaudRate_250=1\n"

   482

    fileContent += "BaudRate_500=1\n"

   483

    fileContent += "BaudRate_800=1\n"

   484

    fileContent += "BaudRate_1000=1\n"

   485

    # Select BootUp type from the informations given by user

   486

    fileContent += "SimpleBootUpMaster=%s\n"%BOOL_TRANSLATE[nodetype == "master"]

   487

    fileContent += "SimpleBootUpSlave=%s\n"%BOOL_TRANSLATE[nodetype == "slave"]

   488

    # CANFestival characteristics

   489

    fileContent += "Granularity=8\n"

   490

    fileContent += "DynamicChannelsSupported=0\n"

   491

    fileContent += "CompactPDO=0\n"

   492

    fileContent += "GroupMessaging=0\n"

   493

    # Calculate receive and tranmit PDO numbers with the entry available

   494

    fileContent += "NrOfRXPDO=%d\n"%len([idx for idx in entries if 0x1400 <= idx <= 0x15FF])

   495

    fileContent += "NrOfTXPDO=%d\n"%len([idx for idx in entries if 0x1800 <= idx <= 0x19FF])

   496

    # LSS not supported as soon as DS-302 was not fully implemented

   497

    fileContent += "LSS_Supported=0\n"

   498

   499

    # Generate Dummy Usage section