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

from __future__ import absolute_import

    13

from __future__ import division

    14

import os

    15

    16

from etherlab.EthercatSlave import ExtractHexDecValue, DATATYPECONVERSION, ExtractName

    17

    18

SLAVE_PDOS_CONFIGURATION_DECLARATION = """

    19

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

    20

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

    21

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

    22

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

    23

 */

    24

    25

ec_pdo_entry_info_t slave_%(slave)d_pdo_entries[] = {

    26

%(pdos_entries_infos)s

    27

};

    28

    29

ec_pdo_info_t slave_%(slave)d_pdos[] = {

    30

%(pdos_infos)s

    31

};

    32

    33

ec_sync_info_t slave_%(slave)d_syncs[] = {

    34

%(pdos_sync_infos)s

    35

    {0xff}

    36

};

    37

"""

    38

    39

SLAVE_CONFIGURATION_TEMPLATE = """

    40

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

    41

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

    42

        goto ecat_failed;

    43

    }

    44

    45

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

    46

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

    47

        goto ecat_failed;

    48

    }

    49

"""

    50

    51

SLAVE_INITIALIZATION_TEMPLATE = """

    52

    {

    53

        uint8_t value[%(data_size)d];

    54

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

    55

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

    56

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

    57

            goto ecat_failed;

    58

        }

    59

    }

    60

"""

    61

    62

SLAVE_OUTPUT_PDO_DEFAULT_VALUE = """

    63

    {

    64

        uint8_t value[%(data_size)d];

    65

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

    66

            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);

    67

            goto ecat_failed;

    68

        }

    69

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

    70

    }

    71

"""

    72

    73

SLAVE_OUTPUT_PDO_DEFAULT_VALUE_BIT = """

    74

    {

    75

        uint8_t value[%(data_size)d];

    76

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

    77

            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);

    78

            goto ecat_failed;

    79

        }

    80

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

    81

    }

    82

"""

    83

    84

    85

SLAVE_INPUT_PDO_DEFAULT_VALUE = """

    86

    {

    87

        uint8_t value[%(data_size)d];

    88

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

    89

            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);

    90

            goto ecat_failed;

    91

        }

    92

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

    93

    }

    94

"""

    95

    96

DC_VARIABLE ="""

    97

#define DC_ENABLE       %(dc_flag)d

    98

"""

    99

   100

CONFIG_DC = """

   101

    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);

   102

"""

   103

   104

   105

def ConfigureVariable(entry_infos, str_completion):

   106

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

   107

    if entry_infos["data_type"] is None:

   108

        msg = _("Type of location \"%s\" not yet supported!") % entry_infos["var_name"]

   109

        raise ValueError(msg)

   110

   111

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

   112

        if "real_var" in entry_infos:

   113

            str_completion["located_variables_declaration"].append(

   114

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

   115

        else:

   116

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

   117

            str_completion["located_variables_declaration"].extend(

   118

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

   119

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

   120

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

   121

            entry_infos["extra_decl"] = declaration

   122

            str_completion["located_variables_declaration"].append(

   123

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

   124

    elif "real_var" not in entry_infos:

   125

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

   126

   127

    str_completion["used_pdo_entry_offset_variables_declaration"].append(

   128

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

   129

   130

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

   131

        str_completion["used_pdo_entry_offset_variables_declaration"].append(

   132

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

   133

   134

        str_completion["used_pdo_entry_configuration"].append(

   135

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

   136

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

   137

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

   138

   139

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

   140

            str_completion["retrieve_variables"].append(

   141

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

   142

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

   143

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

   144

            str_completion["publish_variables"].append(

   145

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

   146

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

   147

   148

    else:

   149

        str_completion["used_pdo_entry_configuration"].append(

   150

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

   151

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

   152

   153

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

   154

            str_completion["retrieve_variables"].append(

   155

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

   156

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

   157

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

   158

            str_completion["publish_variables"].append(

   159

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

   160

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

   161

   162

   163

def ExclusionSortFunction(x, y):

   164

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

   165

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

   166

            return -1

   167

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

   168

            return 1

   169

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

   170

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

   171

   172

   173

class _EthercatCFileGenerator(object):

   174

   175

    def __init__(self, controler):

   176

        self.Controler = controler

   177

   178

        self.Slaves = []

   179

        self.UsedVariables = {}

   180

   181

    def __del__(self):

   182

        self.Controler = None

   183

   184

    def DeclareSlave(self, slave_index, slave):

   185

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

   186

   187

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

   188

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

   189

   190

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

   191

        if entry_infos is None:

   192

            slave_variables[(index, subindex)] = {

   193

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

   194

                "mapped": False}

   195

            return name

   196

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

   197

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

   198

                if dir == "I":

   199

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

   200

                    return entry_infos["infos"][2]

   201

                else:

   202

                    msg = _("Output variables can't be defined with different locations ({a1} and {a2})").\

   203

                          format(a1=entry_infos["infos"][2], a2=name)

   204

                    raise ValueError(msg)

   205

        else:

   206

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

   207

   208

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

   209

   210

        # Extract etherlab master code template

   211

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

   212

        plc_etherlab_file = open(plc_etherlab_filepath, 'r')

   213

        plc_etherlab_code = plc_etherlab_file.read()

   214

        plc_etherlab_file.close()

   215

   216

        # Initialize strings for formatting master code template

   217

        str_completion = {

   218

            "location": location_str,

   219

            "master_number": master_number,

   220

            "located_variables_declaration": [],

   221

            "used_pdo_entry_offset_variables_declaration": [],

   222

            "used_pdo_entry_configuration": [],

   223

            "pdos_configuration_declaration": "",

   224

            "slaves_declaration": "",

   225

            "slaves_configuration": "",

   226

            # add jblee

   227

            "slaves_input_pdos_default_values_extraction": "",

   228

            "slaves_output_pdos_default_values_extraction": "",

   229

            "slaves_initialization": "",

   230

            "retrieve_variables": [],

   231

            "publish_variables": [],

   232

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

   233

            "dc_variable" : "",

   234

            "config_dc": ""

   235

        }

   236

   237

        # Initialize variable storing variable mapping state

   238

        for slave_entries in self.UsedVariables.itervalues():

   239

            for entry_infos in slave_entries.itervalues():

   240

                entry_infos["mapped"] = False

   241

   242

        # Sort slaves by position (IEC_Channel)

   243

        self.Slaves.sort()

   244

        # Initialize dictionary storing alias auto-increment position values

   245

        alias = {}

   246

   247

        # add jblee

   248

        slotNumber = 1

   249

   250

        # Generating code for each slave

   251

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

   252

            type_infos = slave.getType()

   253

   254

            # Defining slave alias and auto-increment position

   255

            if alias.get(slave_alias) is not None:

   256

                alias[slave_alias] += 1

   257

            else:

   258

                alias[slave_alias] = 0

   259

            slave_pos = (slave_alias, alias[slave_alias])

   260

   261

            # Extract slave device informations

   262

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

   263

            if device is None:

   264

                msg = _("No informations found for device %s!") \

   265

                      % (type_infos["device_type"])

   266

                raise ValueError(msg)

   267

   268

            # Extract slaves variables to be mapped

   269

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

   270

   271

            # Extract slave device object dictionary entries

   272

            device_entries = device.GetEntriesList()

   273

   274

            # Adding code for declaring slave in master code template strings

   275

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

   276

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

   277

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

   278

   279

            # Extract slave device CoE informations

   280

            device_coe = device.getCoE()

   281

            if device_coe is not None:

   282

   283

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

   284

                # init commands when initializing slave in master code template strings

   285

                initCmds = []

   286

   287

                for initCmd in device_coe.getInitCmd():

   288

                    initCmds.append({

   289

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

   290

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

   291

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

   292

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

   293

   294

                initCmds.extend(slave.getStartupCommands())

   295

                for initCmd in initCmds:

   296

                    index = initCmd["Index"]

   297

                    subindex = initCmd["Subindex"]

   298

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

   299

                    if entry is not None:

   300

                        data_size = entry["BitSize"] // 8

   301

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

   302

                        init_cmd_infos = {

   303

                            "index": index,

   304

                            "subindex": subindex,

   305

                            "data": data_str,

   306

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

   307

                            "data_size": data_size

   308

                        }

   309

                        init_cmd_infos.update(type_infos)

   310

                        str_completion["slaves_initialization"] += SLAVE_INITIALIZATION_TEMPLATE % init_cmd_infos

   311

   312

                # Extract slave device PDO configuration capabilities

   313

                PdoAssign = device_coe.getPdoAssign()

   314

                PdoConfig = device_coe.getPdoConfig()

   315

            else:

   316

                PdoAssign = PdoConfig = False

   317

   318

            # Test if slave has a configuration or need one

   319

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

   320

   321

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

   322

                str_completion["slaves_configuration"] += SLAVE_CONFIGURATION_TEMPLATE % type_infos

   323

   324

                # Initializing

   325

                pdos_infos = {

   326

                    "pdos_entries_infos": [],

   327

                    "pdos_infos": [],

   328

                    "pdos_sync_infos": [],

   329

                }

   330

                pdos_infos.update(type_infos)

   331

   332

                sync_managers = []

   333

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

   334

                    sync_manager_infos = {

   335

                        "index": sync_manager_idx,

   336

                        "name": sync_manager.getcontent(),

   337

                        "slave": slave_idx,

   338

                        "pdos": [],

   339

                        "pdos_number": 0,

   340

                    }

   341

   342

                    sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())

   343

                    sync_manager_direction = sync_manager_control_byte & 0x0c

   344

                    sync_manager_watchdog = sync_manager_control_byte & 0x40

   345

                    if sync_manager_direction:

   346

                        sync_manager_infos["sync_manager_type"] = "EC_DIR_OUTPUT"

   347

                    else:

   348

                        sync_manager_infos["sync_manager_type"] = "EC_DIR_INPUT"

   349

                    if sync_manager_watchdog:

   350

                        sync_manager_infos["watchdog"] = "EC_WD_ENABLE"

   351

                    else:

   352

                        sync_manager_infos["watchdog"] = "EC_WD_DISABLE"

   353

   354

                    sync_managers.append(sync_manager_infos)

   355

   356

                pdos_index = []

   357

                exclusive_pdos = {}

   358

                selected_pdos = []

   359

   360

                # add jblee

   361

                TxPdoData = []

   362

                RxPdoData = []

   363

                PdoData = []

   364

   365

                # add jblee

   366

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

   367

                    for pdo in device.getTxPdo():

   368

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

   369

                    for pdo in device.getRxPdo():

   370

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

   371

   372

                # mod jblee

   373

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

   374

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

   375

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

   376

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

   377

                PDODataList = []

   378

                MDPData = []

   379

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

   380

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

   381

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

   382

                for PDOIndex in PDOList:

   383

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

   384

                        continue

   385

                    PDODataList.append(int(PDOIndex, 0))

   386

   387

                # add jblee for DC Configuration

   388

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

   389

                sync0_cycle_time = 0

   390

                sync0_shift_time = 0

   391

                sync1_cycle_time = 0

   392

                sync1_shift_time = 0

   393

                if dc_enable :

   394

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

   395

                    if sync0_cycle_token != "None":

   396

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

   397

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

   398

                    if sync0_shift_token != "None":

   399

                        sync0_shift_time = int(sync0_shift_token) * 1000

   400

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

   401

                    if sync1_cycle_token != "None":

   402

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

   403

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

   404

                    if sync1_shift_token != "None":

   405

                        sync1_shift_time = int(sync1_shift_token) * 1000

   406

   407

                    dc_config_data = {

   408

                        "slave" : slave_idx,

   409

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

   410

                        "sync0_cycle_time" : sync0_cycle_time,

   411

                        "sync0_shift_time" : sync0_shift_time,

   412

                        "sync1_cycle_time" : sync1_cycle_time,

   413

                        "sync1_shift_time" : sync1_shift_time,

   414

                    }

   415

   416

                    if dc_enable and not str_completion["dc_variable"] :

   417

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

   418

                    str_completion["config_dc"] += CONFIG_DC % dc_config_data

   419

   420

                for data_file in data_files:

   421

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

   422

                    if os.path.isdir(slave_path):

   423

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

   424

                        confNodeFile = open(CheckConfNodePath, 'r')

   425

                        checklines = confNodeFile.readlines()

   426

                        confNodeFile.close()

   427

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

   428

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

   429

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

   430

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

   431

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

   432

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

   433

                        if slave_idx == pos_check:

   434

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

   435

                            if os.path.isfile(MDPDataFilePath):

   436

                                MDPDataFile = open(MDPDataFilePath, 'r')

   437

                                MDPData = MDPDataFile.readlines()

   438

                                MDPDataFile.close()

   439

   440

                        for MDPLine in MDPData:

   441

                            if MDPLine == "\n":

   442

                                continue

   443

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

   444

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

   445

                            for pdo in module.getTxPdo():

   446

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

   447

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

   448

                            for pdo in module.getRxPdo():

   449

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

   450

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

   451

   452

                for pdo, pdo_type in PdoData:

   453

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

   454

                    pdos_index.append(pdo_index)

   455

   456

                    if PDODataList and (pdo_index in PDODataList):

   457

                        continue

   458

   459

                    excluded_list = pdo.getExclude()

   460

                    if len(excluded_list) > 0:

   461

                        exclusion_list = [pdo_index]

   462

                        for excluded in excluded_list:

   463

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

   464

                        exclusion_list.sort()

   465

   466

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

   467

   468

                        entries = pdo.getEntry()

   469

   470

                        pdo_mapping_match = {

   471

                            "index": pdo_index,

   472

                            "matching": 0,

   473

                            "count": len(entries),

   474

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

   475

                        }

   476

   477

                        exclusion_scope.append(pdo_mapping_match)

   478

   479

                        for entry in entries:

   480

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

   481

                            subindex = ExtractHexDecValue(entry.getSubIndex())

   482

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

   483

                                pdo_mapping_match["matching"] += 1

   484

   485

                        if pdo.getFixed() is not True:

   486

                            pdo_mapping_match["matching"] += \

   487

                                module_extra_params["max_pdo_size"] - \

   488

                                pdo_mapping_match["count"]

   489

   490

                    elif pdo.getMandatory():

   491

                        selected_pdos.append(pdo_index)

   492

   493

                excluded_pdos = []

   494

                for exclusion_scope in exclusive_pdos.itervalues():

   495

                    exclusion_scope.sort(ExclusionSortFunction)

   496

                    start_excluding_index = 0

   497

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