13

    14

#from xml.dom import minidom

    38

EtherCATBaseParser = GenerateParserFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATBase.xsd"))

    39

EtherCATBase_XPath = lambda xpath1: etree.XPath(xpath1)

    40

    47

    60

# Read DefaultValue from ESI file

    61

# Add by jblee 151229

    62

ENTRY_INFOS_KEYS_FOR_DV = [

    63

    ("Index", lambda x: "#x%4.4X" % int(x), "#x0000"),

    64

    ("SubIndex", str, "0"),

    65

    ("Name", str, ""),

    66

    ("Type", str, ""),

    67

    ("BitSize", int, 0),

    68

    ("Access", str, ""),

    69

    ("PDOMapping", str, ""),

    70

    ("DefaultValue", str, ""),

    71

    ("Sub_entry_flag", str, "0")]

    72

    80

        if len(args) > 9:

    81

		    new_entry_infos = {

    85

        else:

    86

            new_entry_infos = {

    87

            key: translate(arg[0]) if len(arg) > 0 else default

    88

            for (key, translate, default), arg

    89

            in zip(ENTRY_INFOS_KEYS_FOR_DV, args)}			

    90

   106

    cls.DataTypes = None

   120

    # Modify by jblee

   121

    def ExtractDataTypes(self):

   122

        #self.DataTypes = {}

   123

        #self.DT = {}

   124

        DT = {}

   125

        objects = []

   126

   127

        # get Profile Field

   128

        for profile in self.getProfile():

   129

            # get each (ProfileNo, Dictionary) Field as child

   130

            for child in profile.getchildren():

   131

                # child.text is not None -> ProfileNo, is None -> Dictionary

   132

                if child.text is None:

   133

                    # get each (DataTypes, Objects) Field 

   134

                    dataTypes = child.getDataTypes()

   135

                    objects = child.getObjects()

   136

   137

                    for dataType in dataTypes.getDataType():

   138

                        #if dataType.getName() is not None:

   139

                        #    print dataType.getName(), dataType

   140

                        DT[dataType.getName()] = dataType

   141

   142

        return DT, objects

   143

    setattr(cls, "ExtractDataTypes", ExtractDataTypes)

   144

   146

        DataTypes, objects = self.ExtractDataTypes()

   147

   149

   150

        # get each Object Field

   151

        for object in objects:

   152

            # Object Field mendatory : Index, Name, Type, BitSize

   153

            # Frequently Use : Info, Flags

   154

            # Info Field -> DefaultData, SubItem

   155

            # Flags Field -> Access, Category, PdoMapping

   156

            object_index = object.getIndex().getcontent()

   157

            index = ExtractHexDecValue(object_index)

   158

            if limits is None or limits[0] <= index <= limits[1]:

   159

                object_type = object.getType()

   160

                object_name = ExtractName(object.getName())

   161

                object_size = object.getBitSize()

   162

                defaultData = ""

   163

                object_access = ""

   164

                object_PDOMapping_data = ""

   165

   166

                object_type_infos = DataTypes.get(object_type, None)

   167

                subItem_infos = object_type_infos.getchildren()

   168

                countSubIndex = 0

   169

                if len(subItem_infos) > 2:

   170

                    for subItem_info in subItem_infos:

   171

                        if subItem_info.tag == "SubItem" : 

   172

                            subItemName = subItem_info.getName()

   173

                            subIdx = subItem_info.getSubIdx()

   174

                            if subIdx is not None:

   175

                                object_subidx = ExtractHexDecValue(subIdx)

   176

                            else:

   177

                                object_subidx = ExtractHexDecValue(countSubIndex)

   178

                            subType = subItem_info.getType()

   179

                            subBitSize = subItem_info.getBitSize()

   180

                            subFlags = subItem_info.getFlags()

   181

                            subAccess = ""

   182

                            subPDOMapping_data = ""

   183

                            if subFlags is not None:

   184

                                subAccess = subFlags.getAccess().getcontent()

   185

                                subPDOMapping = subFlags.getPdoMapping()                                                        

   186

                                if subPDOMapping is not None:

   187

                                    subPDOMapping_data = subFlags.getPdoMapping().upper()

   188

   189

                            entries[(index, object_subidx)] = {

   190

                                "Index": object_index,

   191

                                "SubIndex": subIdx,

   192

                                "Name": "%s - %s" % 

   193

                                    (object_name.decode("utf-8"),

   194

                                     subItemName.decode("utf-8")),

   195

                                "Type": subType,

   196

                                "BitSize": subBitSize,

   197

                                "Access": subAccess, 

   198

                                "PDOMapping": subPDOMapping_data}

   199

   200

                            countSubIndex += 1

   201

   202

                    info = object.getInfo()

   203

                    # subItemTest : check subItem 

   204

                    countSubIndex = 0

   205

                    if info is not None:

   206

                        subItems = info.getchildren()

   207

                        if len(subItems) > 1:

   208

                            for subItem in subItems:

   209

                                defaultdata_subidx = ExtractHexDecValue(countSubIndex)

   210

                                defaultData = subItem.getchildren()[1].findtext("DefaultData")

   211

                                entry = entries.get((index, defaultdata_subidx), None)

   212

                                if entry is not None:

   213

                                    entry["DefaultData"] = defaultData

   214

                                countSubIndex += 1

   215

   216

                else :

   217

                    info = object.getInfo()

   218

                    if info is not None:

   219

                        subItems = info.getchildren()

   220

                        if len(subItems) <= 1:

   221

                            defaultData = subItems[0].text

   222

   223

                    object_flag = object.getFlags()

   224

                    object_access = object_flag.getAccess().getcontent()

   225

                    object_PDOMapping = object_flag.getPdoMapping()

   226

                    if object_PDOMapping is not None:

   227

                        object_PDOMapping_data = object_flag.getPdoMapping().upper()

   228

                    entries[(index, 0)] = {

   229

                        "Index": object_index,

   230

                        "SubIndex": "0",

   231

                        "Name": object_name,                                                               

   232

                        "Type": object_type,

   233

                        "BitSize": object_size,

   234

                        "DefaultData" : defaultData,

   235

                        "Access": object_access, 

   236

                        "PDOMapping": object_PDOMapping_data}

   237

   238

        for TxPdo in self.getTxPdo():

   239

            ExtractPdoInfos(TxPdo, "Transmit", entries, limits)

   240

        for RxPdo in self.getRxPdo():

   241

            ExtractPdoInfos(RxPdo, "Receive", entries, limits)

   246

#    def GetEntriesList(self, limits=None):

   247

#        entries = {}

   248

   249

#        factory = EntryListFactory(entries)

   250

   251

#        entries_list_xslt_tree = etree.XSLT(

   252

#            entries_list_xslt, extensions = {

   253

#                ("entries_list_ns", "AddEntry"): factory.AddEntry,

   254

#                ("entries_list_ns", "HexDecValue"): HexDecValue,

   255

#                ("entries_list_ns", "EntryName"): EntryName})

   256

#        entries_list_xslt_tree(self, **dict(zip(

   257

#            ["min_index", "max_index"], 

   258

#            map(lambda x: etree.XSLT.strparam(str(x)),

   259

#                limits if limits is not None else [0x0000, 0xFFFF])

   260

#            )))

   261

#        

   262

#        return entries

   263

#    setattr(cls, "GetEntriesList", GetEntriesList)

   264

   281

cls2 = EtherCATInfoParser.GetElementClass("DeviceType")

   282

   299

def ExtractPdoInfos(pdo, pdo_type, entries, limits=None):

   300

    pdo_index = pdo.getIndex().getcontent()

   301

    pdo_name = ExtractName(pdo.getName())

   302

    exclude = pdo.getExclude()

   303

    for pdo_entry in pdo.getEntry():

   304

        entry_index = pdo_entry.getIndex().getcontent()

   305

        entry_subindex = pdo_entry.getSubIndex()

   306

        index = ExtractHexDecValue(entry_index)

   307

        subindex = ExtractHexDecValue(entry_subindex)

   308

        object_size = pdo_entry.getBitLen()

   309

   310

        if limits is None or limits[0] <= index <= limits[1]:

   311

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

   312

            if entry is not None:

   313

                entry["PDO index"] = pdo_index

   314

                entry["PDO name"] = pdo_name

   315

                entry["PDO type"] = pdo_type

   316

            else:

   317

                entry_type = pdo_entry.getDataType()

   318

                if entry_type is not None:

   319

                    if pdo_type == "Transmit":

   320

                        access = "ro"

   321

                        pdomapping = "T"

   322

                    else:

   323

                        access = "wo"

   324

                        pdomapping = "R"

   325

                    entries[(index, subindex)] = {

   326

                        "Index": entry_index,

   327

                        "SubIndex": entry_subindex,

   328

                        "Name": ExtractName(pdo_entry.getName()),

   329

                        "Type": entry_type.getcontent(),

   330

                        "BitSize": object_size,

   331

                        "Access": access,

   332

                        "PDOMapping": pdomapping}

   333

   334

#cls3 = EtherCATBaseParser.GetElementClass("ModuleType")

   335

#if cls3:

   336

#    module_xpath = EtherCATBase_XPath("Descriptions/Modules/Module")

   337

#    def test(self):

   338

#        print module_xpath

   339

   340

#    setattr(cls, "test", test)

   341

   342

   380

   389

    module_xpath = EtherCATBase_XPath("Descriptions/Modules/Module")

   390

   393

        # add by jblee for Modular Device Profile

   394

        self.MDPList = []

   395

        self.ModuleList = []

   396

        self.MDPEntryList = {}

   397

        dtDic = {}

   398

        self.idxIncrement = 0

   399

        self.slotIncrement = 0

   400

        # add by jblee for PDO Mapping

   401

        self.DataTypes = {}

   402

        self.ObjectDictionary = {}

   413

                    #if error is not None:

   414

                    #    self.GetCTRoot().logger.write_warning(

   415

                    #        XSDSchemaErrorMessage % (filepath + error))

   419

   430

                        # add for XmlToEeprom Func by jblee.

   431

                        self.LcId_data = group.getchildren()[1]

   432

                        self.Image16x14_data = group.getchildren()[2]

   438

                             "devices": [],

   439

                            # add jblee for support Moduler Device Profile (MDP)

   440

                             "modules": []})

   448

   449

                        # ------------------ Test Section --------------------#

   450

                        slots = device.getSlots()

   451

                        if slots is not None:

   452

                            for slot in slots.getSlot():

   453

                                self.idxIncrement = slot.getSlotIndexIncrement()

   454

                                self.slotIncrement = slot.getSlotPdoIncrement()

   455

                                for child in slot.getchildren():

   456

                                    if child.tag == "ModuleClass":

   457

                                        child_class = child.getClass()

   458

                                        child_name = child.getName()

   459

   460

                    # -------------------- Test Section ----------------------------------# 

   461

                        LocalMDPList = []

   462

                        for module in self.module_xpath(self.modules_infos):

   463

                            module_type = module.getType().getModuleClass()

   464

                            module_name = module.getName()

   465

                            LocalMDPData = ExtractName(module_name) + " (" + module_type + ")"

   466

   467

                            self.ModuleList.append(module)

   468

                            try :

   469

                                module_pdos = module.getTxPdo()

   470

                                module_pdos += module.getRxPdo()

   471

                                for module_pdo in module_pdos:

   472

                                    device_name = ExtractName(module_name)

   473

                                    pdo_index = module_pdo.getIndex().getcontent()

   474

                                    pdo_name = ExtractName(module_pdo.getName())

   475

                                    pdo_entry = module_pdo.getEntry()

   476

                                    if module_pdo.tag == "TxPdo":

   477

                                        mapping_type = "T"

   478

                                    else :

   479

                                        mapping_type = "R"

   480

   481

                                    LocalMDPEntry = []

   482

                                    for entry in pdo_entry:

   483

                                        entry_index = entry.getIndex().getcontent()

   484

                                        entry_subidx = entry.getSubIndex()

   485

                                        entry_name = ExtractName(entry.getName())

   486

                                        entry_bitsize = entry.getBitLen()

   487

                                        try :

   488

                                           entry_type = entry.getDataType().getcontent()

   489

                                        except :

   490

                                           entry_type = ""

   491

   492

                                        LocalMDPEntry.append({