1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz

     5

#

     6

# Copyright (C) 2011-2014: Laurent BESSARD, Edouard TISSERANT

     7

#                          RTES Lab : CRKim, JBLee, youcu

     8

#                          Higen Motor : Donggu Kang

     9

#

    10

# See COPYING file for copyrights details.

    11

    12

import os

    13

    14

from EthercatSlave import ExtractHexDecValue, DATATYPECONVERSION, ExtractName

    15

    16

SLAVE_PDOS_CONFIGURATION_DECLARATION = """

    17

/* Slave %(slave)d, "%(device_type)s"

    18

 * Vendor ID:       0x%(vendor).8x

    19

 * Product code:    0x%(product_code).8x

    20

 * Revision number: 0x%(revision_number).8x

    21

 */

    22

    23

ec_pdo_entry_info_t slave_%(slave)d_pdo_entries[] = {

    24

%(pdos_entries_infos)s

    25

};

    26

    27

ec_pdo_info_t slave_%(slave)d_pdos[] = {

    28

%(pdos_infos)s

    29

};

    30

    31

ec_sync_info_t slave_%(slave)d_syncs[] = {

    32

%(pdos_sync_infos)s

    33

    {0xff}

    34

};

    35

"""

    36

    37

SLAVE_CONFIGURATION_TEMPLATE = """

    38

    if (!(slave%(slave)d = ecrt_master_slave_config(master, %(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x))) {

    39

        SLOGF(LOG_CRITICAL, "EtherCAT failed to get slave %(device_type)s configuration at alias %(alias)d and position %(position)d.");

    40

        goto ecat_failed;

    41

    }

    42

    43

    if (ecrt_slave_config_pdos(slave%(slave)d, EC_END, slave_%(slave)d_syncs)) {

    44

        SLOGF(LOG_CRITICAL, "EtherCAT failed to configure PDOs for slave %(device_type)s at alias %(alias)d and position %(position)d.");

    45

        goto ecat_failed;

    46

    }

    47

"""

    48

    49

SLAVE_INITIALIZATION_TEMPLATE = """

    50

    {

    51

        uint8_t value[%(data_size)d];

    52

        EC_WRITE_%(data_type)s((uint8_t *)value, %(data)s);

    53

        if (ecrt_master_sdo_download(master, %(slave)d, 0x%(index).4x, 0x%(subindex).2x, (uint8_t *)value, %(data_size)d, &abort_code)) {

    54

            SLOGF(LOG_CRITICAL, "EtherCAT Failed to initialize slave %(device_type)s at alias %(alias)d and position %(position)d. Error: %%d", abort_code);

    55

            goto ecat_failed;

    56

        }

    57

    }

    58

"""

    59

    60

SLAVE_OUTPUT_PDO_DEFAULT_VALUE = """

    61

    {

    62

        uint8_t value[%(data_size)d];

    63

        if (ecrt_master_sdo_upload(master, %(slave)d, 0x%(index).4x, 0x%(subindex).2x, (uint8_t *)value, %(data_size)d, &result_size, &abort_code)) {

    64

            SLOGF(LOG_CRITICAL, "EtherCAT failed to get default value for output PDO in slave %(device_type)s at alias %(alias)d and position %(position)d. Error: %%ud", abort_code);

    65

            goto ecat_failed;

    66

        }

    67

        %(real_var)s = EC_READ_%(data_type)s((uint8_t *)value);

    68

    }

    69

"""

    70

    71

SLAVE_OUTPUT_PDO_DEFAULT_VALUE_BIT = """

    72

    {

    73

        uint8_t value[%(data_size)d];

    74

        if (ecrt_master_sdo_upload(master, %(slave)d, 0x%(index).4x, 0x%(subindex).2x, (uint8_t *)value, %(data_size)d, &result_size, &abort_code)) {

    75

            SLOGF(LOG_CRITICAL, "EtherCAT failed to get default value for output PDO in slave %(device_type)s at alias %(alias)d and position %(position)d. Error: %%ud", abort_code);

    76

            goto ecat_failed;

    77

        }

    78

        %(real_var)s = EC_READ_%(data_type)s((uint8_t *)value, %(subindex)d);

    79

    }

    80

"""

    81

    82

    83

SLAVE_INPUT_PDO_DEFAULT_VALUE = """

    84

    {

    85

        uint8_t value[%(data_size)d];

    86

        if (ecrt_master_sdo_upload(master, %(slave)d, 0x%(index).4x, 0x%(subindex).2x, (uint8_t *)value, %(data_size)d, &result_size, &abort_code)) {

    87

            SLOGF(LOG_CRITICAL, "EtherCAT failed to get default value for input PDO in slave %(device_type)s at alias %(alias)d and position %(position)d. Error: %%ud", abort_code);

    88

            goto ecat_failed;

    89

        }

    90

        %(real_var)s = EC_READ_%(data_type)s((uint8_t *)value);

    91

    }

    92

"""

    93

    94

DC_VARIABLE ="""

    95

#define DC_ENABLE       %(dc_flag)d

    96

"""

    97

    98

CONFIG_DC = """

    99

    ecrt_slave_config_dc (slave%(slave)d, 0x0%(assign_activate)ld, %(sync0_cycle_time)d, %(sync0_shift_time)d, %(sync1_cycle_time)d, %(sync1_shift_time)d);

   100

"""

   101

   102

   103

def ConfigureVariable(entry_infos, str_completion):

   104

    entry_infos["data_type"] = DATATYPECONVERSION.get(entry_infos["var_type"], None)

   105

    if entry_infos["data_type"] is None:

   106

        raise ValueError, _("Type of location \"%s\" not yet supported!") % entry_infos["var_name"]

   107

   108

    if not entry_infos.get("no_decl", False):

   109

        if entry_infos.has_key("real_var"):

   110

            str_completion["located_variables_declaration"].append(

   111

                "IEC_%(var_type)s %(real_var)s;" % entry_infos)

   112

        else:

   113

            entry_infos["real_var"] = "beremiz" + entry_infos["var_name"]

   114

            str_completion["located_variables_declaration"].extend(

   115

                ["IEC_%(var_type)s %(real_var)s;" % entry_infos,

   116

                 "IEC_%(var_type)s *%(var_name)s = &%(real_var)s;" % entry_infos])

   117

        for declaration in entry_infos.get("extra_declarations", []):

   118

            entry_infos["extra_decl"] = declaration

   119

            str_completion["located_variables_declaration"].append(

   120

                 "IEC_%(var_type)s *%(extra_decl)s = &%(real_var)s;" % entry_infos)

   121

    elif not entry_infos.has_key("real_var"):

   122

        entry_infos["real_var"] = "beremiz" + entry_infos["var_name"]

   123

   124

    str_completion["used_pdo_entry_offset_variables_declaration"].append(

   125

        "unsigned int slave%(slave)d_%(index).4x_%(subindex).2x;" % entry_infos)

   126

   127

    if entry_infos["data_type"] == "BIT":

   128

        str_completion["used_pdo_entry_offset_variables_declaration"].append(

   129

            "unsigned int slave%(slave)d_%(index).4x_%(subindex).2x_bit;" % entry_infos)

   130

   131

        str_completion["used_pdo_entry_configuration"].append(

   132

             ("    {%(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x, " + 

   133

              "0x%(index).4x, %(subindex)d, &slave%(slave)d_%(index).4x_%(subindex).2x, " + 

   134

              "&slave%(slave)d_%(index).4x_%(subindex).2x_bit},") % entry_infos)

   135

   136

        if entry_infos["dir"] == "I":

   137

            str_completion["retrieve_variables"].append(

   138

              ("    %(real_var)s = EC_READ_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " + 

   139

               "slave%(slave)d_%(index).4x_%(subindex).2x_bit);") % entry_infos)

   140

        elif entry_infos["dir"] == "Q":

   141

            str_completion["publish_variables"].append(

   142

              ("    EC_WRITE_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " + 

   143

               "slave%(slave)d_%(index).4x_%(subindex).2x_bit, %(real_var)s);") % entry_infos)

   144

   145

    else:

   146

        str_completion["used_pdo_entry_configuration"].append(

   147

            ("    {%(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x, 0x%(index).4x, " + 

   148

             "%(subindex)d, &slave%(slave)d_%(index).4x_%(subindex).2x},") % entry_infos)

   149

   150

        if entry_infos["dir"] == "I":

   151

            str_completion["retrieve_variables"].append(

   152

                ("    %(real_var)s = EC_READ_%(data_type)s(domain1_pd + " + 

   153

                 "slave%(slave)d_%(index).4x_%(subindex).2x);") % entry_infos)

   154

        elif entry_infos["dir"] == "Q":

   155

            str_completion["publish_variables"].append(

   156

                ("    EC_WRITE_%(data_type)s(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " + 

   157

                 "%(real_var)s);") % entry_infos)

   158

   159

def ExclusionSortFunction(x, y):

   160

    if x["matching"] == y["matching"]:

   161

        if x["assigned"] and not y["assigned"]:

   162

            return -1

   163

        elif not x["assigned"] and y["assigned"]:

   164

            return 1

   165

        return cmp(x["count"], y["count"])

   166

    return -cmp(x["matching"], y["matching"])

   167

   168

class _EthercatCFileGenerator:

   169

   170

    def __init__(self, controler):

   171

        self.Controler = controler

   172

   173

        self.Slaves = []

   174

        self.UsedVariables = {}

   175

   176

    def __del__(self):

   177

        self.Controler = None            

   178

   179

    def DeclareSlave(self, slave_index, slave):

   180

        self.Slaves.append((slave_index, slave.getInfo().getAutoIncAddr(), slave))

   181

   182

    def DeclareVariable(self, slave_index, index, subindex, iec_type, dir, name, no_decl=False):

   183

        slave_variables = self.UsedVariables.setdefault(slave_index, {})

   184

   185

        entry_infos = slave_variables.get((index, subindex), None)

   186

        if entry_infos is None:

   187

            slave_variables[(index, subindex)] = {

   188

                "infos": (iec_type, dir, name, no_decl, []),

   189

                "mapped": False}

   190

            return name

   191

        elif entry_infos["infos"][:2] == (iec_type, dir):

   192

            if name != entry_infos["infos"][2]:

   193

                if dir == "I":

   194

                    entry_infos["infos"][4].append(name)

   195

                    return entry_infos["infos"][2]

   196

                else:

   197

                    raise ValueError, _("Output variables can't be defined with different locations (%s and %s)") % (entry_infos["infos"][2], name)

   198

        else:

   199

            raise ValueError, _("Definition conflict for location \"%s\"") % name 

   200

   201

    def GenerateCFile(self, filepath, location_str, master_number):

   202

        # Extract etherlab master code template

   203

        plc_etherlab_filepath = os.path.join(os.path.split(__file__)[0], "plc_etherlab.c")

   204

        plc_etherlab_file = open(plc_etherlab_filepath, 'r')

   205

        plc_etherlab_code = plc_etherlab_file.read()

   206

        plc_etherlab_file.close()

   207

   208

        # Initialize strings for formatting master code template

   209

        str_completion = {

   210

            "location": location_str,

   211

            "master_number": master_number,

   212

            "located_variables_declaration": [],

   213

            "used_pdo_entry_offset_variables_declaration": [],

   214

            "used_pdo_entry_configuration": [],

   215

            "pdos_configuration_declaration": "",

   216

            "slaves_declaration": "",

   217

            "slaves_configuration": "",

   218

            # add jblee

   219

            "slaves_input_pdos_default_values_extraction": "",

   220

            "slaves_output_pdos_default_values_extraction": "",

   221

            "slaves_initialization": "",

   222

            "retrieve_variables": [],

   223

            "publish_variables": [],

   224

            #-----------This Code templete for dc -------------------#

   225

            "dc_variable" : "",

   226

            "config_dc": ""

   227

        }

   228

   229

        # Initialize variable storing variable mapping state

   230

        for slave_entries in self.UsedVariables.itervalues():

   231

            for entry_infos in slave_entries.itervalues():

   232

                entry_infos["mapped"] = False

   233

   234

        # Sort slaves by position (IEC_Channel)

   235

        self.Slaves.sort()

   236

        # Initialize dictionary storing alias auto-increment position values

   237

        alias = {}

   238

   239

        # add jblee

   240

        slotNumber = 1

   241

   242

        # Generating code for each slave

   243

        for (slave_idx, slave_alias, slave) in self.Slaves:

   244

            type_infos = slave.getType()

   245

   246

            # Defining slave alias and auto-increment position

   247

            if alias.get(slave_alias) is not None:

   248

                alias[slave_alias] += 1

   249

            else:

   250

                alias[slave_alias] = 0

   251

            slave_pos = (slave_alias, alias[slave_alias])

   252

   253

            # Extract slave device informations

   254

            device, module_extra_params = self.Controler.GetModuleInfos(type_infos)

   255

            if device is None:

   256

                raise ValueError, _("No informations found for device %s!") % (type_infos["device_type"])

   257

   258

            # Extract slaves variables to be mapped

   259

            slave_variables = self.UsedVariables.get(slave_idx, {})

   260

   261

            # Extract slave device object dictionary entries

   262

            device_entries = device.GetEntriesList()

   263

            #device_entries = self.Controler.CTNParent.GetEntriesList()

   264

   265

            # Adding code for declaring slave in master code template strings

   266

            for element in ["vendor", "product_code", "revision_number"]:

   267

                type_infos[element] = ExtractHexDecValue(type_infos[element])

   268

            type_infos.update(dict(zip(["slave", "alias", "position"], (slave_idx,) + slave_pos)))

   269

   270

            # Extract slave device CoE informations

   271

            device_coe = device.getCoE()

   272

            if device_coe is not None:

   273

                # If device support CanOpen over Ethernet, adding code for calling 

   274

                # init commands when initializing slave in master code template strings

   275

                initCmds = []

   276

   277

                for initCmd in device_coe.getInitCmd():

   278

                    initCmds.append({

   279

                        "Index": ExtractHexDecValue(initCmd.getIndex()),

   280

                        "Subindex": ExtractHexDecValue(initCmd.getSubIndex()),

   281

                        #"Value": initCmd.getData().getcontent()})

   282

                        "Value": int(initCmd.getData().text, 16)})

   283

   284

                initCmds.extend(slave.getStartupCommands())

   285

                for initCmd in initCmds:

   286

                    index = initCmd["Index"]

   287

                    subindex = initCmd["Subindex"]

   288

                    entry = device_entries.get((index, subindex), None)

   289

                    if entry is not None:

   290

                        data_size = entry["BitSize"] / 8

   291

                        data_str = ("0x%%.%dx" % (data_size * 2)) % initCmd["Value"]

   292

                        init_cmd_infos = {

   293

                            "index": index,

   294

                            "subindex": subindex,

   295

                            "data": data_str,

   296

                            "data_type": DATATYPECONVERSION.get(entry["Type"]),

   297

                            "data_size": data_size

   298

                        }

   299

                        init_cmd_infos.update(type_infos)

   300

                        str_completion["slaves_initialization"] += SLAVE_INITIALIZATION_TEMPLATE % init_cmd_infos

   301

   302

                # Extract slave device PDO configuration capabilities

   303

                PdoAssign = device_coe.getPdoAssign()

   304

                PdoConfig = device_coe.getPdoConfig()

   305

            else:

   306

                PdoAssign = PdoConfig = False

   307

   308

            # Test if slave has a configuration or need one

   309

            #if len(device.getTxPdo() + device.getRxPdo()) > 0 or len(slave_variables) > 0 and PdoConfig and PdoAssign:

   310

            if len(device.getTxPdo() + device.getRxPdo()) > 0 or len(slave_variables) > 0 or device.getSlots() is not None:

   311

                str_completion["slaves_declaration"] += "static ec_slave_config_t *slave%(slave)d = NULL;\n" % type_infos

   312

                str_completion["slaves_configuration"] += SLAVE_CONFIGURATION_TEMPLATE % type_infos

   313

   314

                # Initializing 

   315

                pdos_infos = {

   316

                    "pdos_entries_infos": [],

   317

                    "pdos_infos": [],

   318

                    "pdos_sync_infos": [], 

   319

                }

   320

                pdos_infos.update(type_infos)

   321

   322

                sync_managers = []

   323

                for sync_manager_idx, sync_manager in enumerate(device.getSm()):

   324

                    sync_manager_infos = {

   325

                        "index": sync_manager_idx, 

   326

                        "name": sync_manager.getcontent(),

   327

                        "slave": slave_idx,

   328

                        "pdos": [], 

   329

                        "pdos_number": 0,

   330

                    }

   331

   332

                    sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())

   333

                    sync_manager_direction = sync_manager_control_byte & 0x0c

   334

                    sync_manager_watchdog = sync_manager_control_byte & 0x40

   335

                    if sync_manager_direction:

   336

                        sync_manager_infos["sync_manager_type"] = "EC_DIR_OUTPUT"

   337

                    else:

   338

                        sync_manager_infos["sync_manager_type"] = "EC_DIR_INPUT"

   339

                    if sync_manager_watchdog:

   340

                        sync_manager_infos["watchdog"] = "EC_WD_ENABLE"

   341

                    else:

   342

                        sync_manager_infos["watchdog"] = "EC_WD_DISABLE"

   343

   344

                    sync_managers.append(sync_manager_infos)

   345

   346

                pdos_index = []

   347

                exclusive_pdos = {}

   348

                selected_pdos = []

   349

   350

                # add jblee

   351

                TxPdoData = []

   352

                RxPdoData = []

   353

                PdoData = []

   354

   355

                # add jblee

   356

                if len(device.getTxPdo() + device.getRxPdo()) > 0:

   357

                    for pdo in device.getTxPdo():

   358

                        PdoData.append((pdo, "Inputs"))

   359

                    for pdo in device.getRxPdo():

   360

                        PdoData.append((pdo, "Outputs"))               

   361

   362

                # mod jblee

   363

                #for pdo, pdo_type in ([(pdo, "Inputs") for pdo in device.getTxPdo()] +

   364

                #                      [(pdo, "Outputs") for pdo in device.getRxPdo()]):

   365

                #for pdo, pdo_type in (TxPdoData + RxPdoData):

   366

                data_files = os.listdir(self.Controler.CTNPath())

   367

                PDODataList = []

   368

                MDPData = []

   369

                RxPDOData = self.Controler.GetChildByIECLocation((slave_idx,)).BaseParams.getRxPDO()

   370

                TxPDOData = self.Controler.GetChildByIECLocation((slave_idx,)).BaseParams.getTxPDO()

   371

                PDOList = RxPDOData.split() + TxPDOData.split()

   372

                for PDOIndex in PDOList:

   373

                    if PDOIndex in ["RxPDO", "TxPDO", "None"]:

   374

                        continue

   375

                    PDODataList.append(int(PDOIndex, 0))

   376

   377

                # add jblee for DC Configuration

   378

                dc_enable = self.Controler.GetChildByIECLocation((slave_idx,)).BaseParams.getDC_Enable()

   379

                sync0_cycle_time = 0

   380

                sync0_shift_time = 0

   381

                sync1_cycle_time = 0

   382

                sync1_shift_time = 0

   383

                if dc_enable :

   384

                    sync0_cycle_token = self.Controler.GetChildByIECLocation((slave_idx,)).BaseParams.getDC_Sync0_Cycle_Time()

   385

                    if sync0_cycle_token != "None":

   386

                        sync0_cycle_time = int(sync0_cycle_token.split("_")[1]) * 1000

   387

                    sync0_shift_token = self.Controler.GetChildByIECLocation((slave_idx,)).BaseParams.getDC_Sync0_Shift_Time()

   388

                    if sync0_shift_token != "None":

   389

                        sync0_shift_time = int(sync0_shift_token) * 1000

   390

                    sync1_cycle_token = self.Controler.GetChildByIECLocation((slave_idx,)).BaseParams.getDC_Sync1_Cycle_Time()

   391

                    if sync1_cycle_token != "None":

   392

                        sync1_cycle_time = int(sync1_cycle_token.split("_")[1]) * 1000

   393

                    sync1_shift_token = self.Controler.GetChildByIECLocation((slave_idx,)).BaseParams.getDC_Sync1_Shift_Time()

   394

                    if sync1_shift_token != "None":

   395

                        sync1_shift_time = int(sync1_shift_token) * 1000

   396

   397

                    dc_config_data = {

   398

                        "slave" : slave_idx,

   399

                        "assign_activate" : int(self.Controler.GetChildByIECLocation((slave_idx,)).BaseParams.getDC_Assign_Activate()),

   400

                        "sync0_cycle_time" : sync0_cycle_time,

   401

                        "sync0_shift_time" : sync0_shift_time,

   402

                        "sync1_cycle_time" : sync1_cycle_time,

   403

                        "sync1_shift_time" : sync1_shift_time,

   404

                    }

   405

   406

                    if dc_enable and not str_completion["dc_variable"] :

   407

                        str_completion["dc_variable"] += DC_VARIABLE % {"dc_flag" : dc_enable}

   408

                    str_completion["config_dc"] += CONFIG_DC % dc_config_data

   409

   410

                for data_file in data_files:

   411

                    slave_path = os.path.join(self.Controler.CTNPath(), data_file)

   412

                    if os.path.isdir(slave_path):

   413

                        CheckConfNodePath = os.path.join(slave_path, "baseconfnode.xml")

   414

                        confNodeFile = open(CheckConfNodePath, 'r')

   415

                        checklines = confNodeFile.readlines()

   416

                        confNodeFile.close()

   417

                        # checklines(ex) : <BaseParams xmlns:xsd="http://www.w3.org/2001/XMLSchema" IEC_Channel="0" Name="EthercatSlave_0"/>

   418

                        # checklines[1].split() : [<BaseParams, xmlns:xsd="http://www.w3.org/2001/XMLSchema",

   419

                        #                           IEC_Channel="0", Name="EthercatSlave_0"/>]

   420

                        # checklines[1].split()[2] : IEC_Channel="0"

   421

                        # checklines[1].split()[2].split("\"") = [IEC_Channel=, 0, ]

   422

                        pos_check = int(checklines[1].split()[2].split("\"")[1])

   423

                        if slave_idx == pos_check:

   424

                            MDPDataFilePath = os.path.join(slave_path, "DataForMDP.txt")

   425

                            if os.path.isfile(MDPDataFilePath):

   426

                                MDPDataFile = open(MDPDataFilePath, 'r')

   427

                                MDPData = MDPDataFile.readlines()

   428

                                MDPDataFile.close()

   429

   430

                        for MDPLine in MDPData:

   431

                            if MDPLine == "\n":

   432

                                continue

   433

                            module_pos = int(MDPLine.split()[-1])

   434

                            module = self.Controler.CTNParent.GetSelectModule(module_pos)

   435

                            for pdo in module.getTxPdo():

   436

                                PdoData.append((pdo, "Inputs"))

   437

                                PDODataList.append(ExtractHexDecValue(pdo.getIndex().getcontent()))

   438

                            for pdo in module.getRxPdo():

   439

                                PdoData.append((pdo, "Outputs"))

   440

                                PDODataList.append(ExtractHexDecValue(pdo.getIndex().getcontent()))

   441

   442

                for pdo, pdo_type in PdoData:

   443

                    pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())

   444

                    pdos_index.append(pdo_index)

   445

   446

                    if PDODataList and (pdo_index in PDODataList):

   447

                        continue

   448

   449

                    excluded_list = pdo.getExclude()

   450

                    if len(excluded_list) > 0:

   451

                        exclusion_list = [pdo_index]

   452

                        for excluded in excluded_list:

   453

                            exclusion_list.append(ExtractHexDecValue(excluded.getcontent()))

   454

                        exclusion_list.sort()                     

   455

                        exclusion_scope = exclusive_pdos.setdefault(tuple(exclusion_list), [])                   

   456

                        entries = pdo.getEntry()

   457

   458

                        pdo_mapping_match = {

   459

                            "index": pdo_index, 

   460

                            "matching": 0, 

   461

                            "count": len(entries), 

   462

                            "assigned": pdo.getSm() is not None

   463

                        }

   464

   465

                        exclusion_scope.append(pdo_mapping_match)

   466

   467

                        for entry in entries:

   468

                            index = ExtractHexDecValue(entry.getIndex().getcontent())

   469

                            subindex = ExtractHexDecValue(entry.getSubIndex())

   470

                            if slave_variables.get((index, subindex), None) is not None:

   471

                                pdo_mapping_match["matching"] += 1

   472

   473

                        if pdo.getFixed() != True:

   474

                            pdo_mapping_match["matching"] += \

   475

                                module_extra_params["max_pdo_size"] - \

   476

                                pdo_mapping_match["count"]

   477

   478

                    elif pdo.getMandatory():

   479

                        selected_pdos.append(pdo_index)

   480

   481

                excluded_pdos = []

   482

                for exclusion_scope in exclusive_pdos.itervalues():

   483

                    exclusion_scope.sort(ExclusionSortFunction)

   484

                    start_excluding_index = 0

   485

                    if exclusion_scope[0]["matching"] > 0:

   486

                        selected_pdos.append(exclusion_scope[0]["index"])

   487

                        start_excluding_index = 1

   488

                    excluded_pdos.extend([pdo["index"] 

   489

                        for pdo in exclusion_scope[start_excluding_index:] 

   490

                        if PdoAssign or not pdo["assigned"]])

   491

   492

                # mod jblee

   493

                #for pdo, pdo_type in ([(pdo, "Inputs") for pdo in device.getTxPdo()] +

   494

                #                      [(pdo, "Outputs") for pdo in device.getRxPdo()]):

   495

                #for pdo, pdo_type in (TxPdoData + RxPdoData):

   496

                entry_check_list = []

   497

                index_padding = 1

   498

                for pdo, pdo_type in PdoData:

   499

                    entries = pdo.getEntry()                   

   500

   501

                    pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())

   502

                    if pdo_index in excluded_pdos:

   503

                        continue

   504

                    if PDODataList and (pdo_index not in PDODataList):

   505

                        continue

   506