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

import os

    14

import shutil

    15

import csv

    16

    17

from lxml import etree

    18

import wx

    19

    20

from xmlclass import *

    21

    22

from ConfigTreeNode import XSDSchemaErrorMessage

    23

    24

from etherlab.EthercatSlave import ExtractHexDecValue, ExtractName

    25

from etherlab.EthercatMaster import _EthercatCTN

    26

from etherlab.ConfigEditor import LibraryEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    27

    28

ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]

    29

    30

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

    31

#                 Ethercat ConfNode

    32

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

    33

    34

EtherCATInfoParser = GenerateParserFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATInfo.xsd"))

    35

    36

    37

def EtherCATInfo_XPath(xpath):

    38

    return etree.XPath(xpath)

    39

    40

    41

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

    42

    43

    44

def EtherCATBase_XPath(xpath):

    45

    return etree.XPath(xpath)

    46

    47

    48

def HexDecValue(context, *args):

    49

    return str(ExtractHexDecValue(args[0][0]))

    50

    51

    52

def EntryName(context, *args):

    53

    return ExtractName(args[0], args[1][0] if len(args) > 1 else None)

    54

    55

    56

ENTRY_INFOS_KEYS = [

    57

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

    58

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

    59

    ("Name", str, ""),

    60

    ("Type", str, ""),

    61

    ("BitSize", int, 0),

    62

    ("Access", str, ""),

    63

    ("PDOMapping", str, ""),

    64

    ("PDO index", str, ""),

    65

    ("PDO name", str, ""),

    66

    ("PDO type", str, "")]

    67

    68

# Read DefaultValue from ESI file

    69

# Add by jblee 151229

    70

ENTRY_INFOS_KEYS_FOR_DV = [

    71

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

    72

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

    73

    ("Name", str, ""),

    74

    ("Type", str, ""),

    75

    ("BitSize", int, 0),

    76

    ("Access", str, ""),

    77

    ("PDOMapping", str, ""),

    78

    ("DefaultValue", str, ""),

    79

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

    80

    81

class EntryListFactory(object):

    82

    83

    def __init__(self, entries):

    84

        self.Entries = entries

    85

    86

    def AddEntry(self, context, *args):

    87

        index, subindex = map(lambda x: int(x[0]), args[:2])

    88

        if len(args) > 9:

    89

		    new_entry_infos = {

    90

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

    91

            for (key, translate, default), arg

    92

            in zip(ENTRY_INFOS_KEYS, args)}

    93

        else:

    94

            new_entry_infos = {

    95

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

    96

            for (key, translate, default), arg

    97

            in zip(ENTRY_INFOS_KEYS_FOR_DV, args)}			

    98

    99

        if (index, subindex) != (0, 0):

   100

            entry_infos = self.Entries.get((index, subindex))

   101

            if entry_infos is not None:

   102

                for param in ["PDO index", "PDO name", "PDO type"]:

   103

                    value = new_entry_infos.get(param)

   104

                    if value is not None:

   105

                        entry_infos[param] = value

   106

            else:

   107

                self.Entries[(index, subindex)] = new_entry_infos

   108

   109

   110

entries_list_xslt = etree.parse(

   111

    os.path.join(ScriptDirectory, "entries_list.xslt"))

   112

   113

cls = EtherCATInfoParser.GetElementClass("DeviceType")

   114

if cls:

   115

    cls.DataTypes = None

   116

   117

    profile_numbers_xpath = EtherCATInfo_XPath("Profile/ProfileNo")

   118

   119

    def GetProfileNumbers(self):

   120

        return [number.text for number in profile_numbers_xpath(self)]

   121

    setattr(cls, "GetProfileNumbers", GetProfileNumbers)

   122

   123

    def getCoE(self):

   124

        mailbox = self.getMailbox()

   125

        if mailbox is not None:

   126

            return mailbox.getCoE()

   127

        return None

   128

    setattr(cls, "getCoE", getCoE)

   129

   130

    # Modify by jblee

   131

    def ExtractDataTypes(self):

   132

        #self.DataTypes = {}

   133

        #self.DT = {}

   134

        DT = {}

   135

        objects = []

   136

   137

        # get Profile Field

   138

        for profile in self.getProfile():

   139

            # get each (ProfileNo, Dictionary) Field as child

   140

            for child in profile.getchildren():

   141

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

   142

                if child.text is None:

   143

                    # get each (DataTypes, Objects) Field 

   144

                    dataTypes = child.getDataTypes()

   145

                    objects = child.getObjects()

   146

   147

                    for dataType in dataTypes.getDataType():

   148

                        #if dataType.getName() is not None:

   149

                        #    print dataType.getName(), dataType

   150

                        DT[dataType.getName()] = dataType

   151

   152

        return DT, objects

   153

    setattr(cls, "ExtractDataTypes", ExtractDataTypes)

   154

   155

    def GetEntriesList(self, limits=None):

   156

        DataTypes, objects = self.ExtractDataTypes()

   157

   158

        entries = {}

   159

   160

        # get each Object Field

   161

        for object in objects:

   162

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

   163

            # Frequently Use : Info, Flags

   164

            # Info Field -> DefaultData, SubItem

   165

            # Flags Field -> Access, Category, PdoMapping

   166

            object_index = object.getIndex().getcontent()

   167

            index = ExtractHexDecValue(object_index)

   168

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

   169

                object_type = object.getType()

   170

                object_name = ExtractName(object.getName())

   171

                object_size = object.getBitSize()

   172

                defaultData = ""

   173

                object_access = ""

   174

                object_PDOMapping_data = ""

   175

   176

                object_type_infos = DataTypes.get(object_type, None)

   177

                subItem_infos = object_type_infos.getchildren()

   178

                countSubIndex = 0

   179

                if len(subItem_infos) > 2:

   180

                    for subItem_info in subItem_infos:

   181

                        if subItem_info.tag == "SubItem" : 

   182

                            subItemName = subItem_info.getName()

   183

                            subIdx = subItem_info.getSubIdx()

   184

                            if subIdx is not None:

   185

                                object_subidx = ExtractHexDecValue(subIdx)

   186

                            else:

   187

                                object_subidx = ExtractHexDecValue(countSubIndex)

   188

                            subType = subItem_info.getType()

   189

                            subBitSize = subItem_info.getBitSize()

   190

                            subFlags = subItem_info.getFlags()

   191

                            subAccess = ""

   192

                            subPDOMapping_data = ""

   193

                            if subFlags is not None:

   194

                                subAccess = subFlags.getAccess().getcontent()

   195

                                subPDOMapping = subFlags.getPdoMapping()                                                        

   196

                                if subPDOMapping is not None:

   197

                                    subPDOMapping_data = subFlags.getPdoMapping().upper()

   198

   199

                            entries[(index, object_subidx)] = {

   200

                                "Index": object_index,

   201

                                "SubIndex": subIdx,

   202

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

   203

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

   204

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

   205

                                "Type": subType,

   206

                                "BitSize": subBitSize,

   207

                                "Access": subAccess, 

   208

                                "PDOMapping": subPDOMapping_data}

   209

   210

                            countSubIndex += 1

   211

   212

                    info = object.getInfo()

   213

                    # subItemTest : check subItem 

   214

                    countSubIndex = 0

   215

                    if info is not None:

   216

                        subItems = info.getchildren()

   217

                        if len(subItems) > 1:

   218

                            for subItem in subItems:

   219

                                defaultdata_subidx = ExtractHexDecValue(countSubIndex)

   220

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

   221

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

   222

                                if entry is not None:

   223

                                    entry["DefaultData"] = defaultData

   224

                                countSubIndex += 1

   225

   226

                else :

   227

                    info = object.getInfo()

   228

                    if info is not None:

   229

                        subItems = info.getchildren()

   230

                        if len(subItems) <= 1:

   231

                            defaultData = subItems[0].text

   232

   233

                    object_flag = object.getFlags()

   234

                    object_access = object_flag.getAccess().getcontent()

   235

                    object_PDOMapping = object_flag.getPdoMapping()

   236

                    if object_PDOMapping is not None:

   237

                        object_PDOMapping_data = object_flag.getPdoMapping().upper()

   238

                    entries[(index, 0)] = {

   239

                        "Index": object_index,

   240

                        "SubIndex": "0",

   241

                        "Name": object_name,                                                               

   242

                        "Type": object_type,

   243

                        "BitSize": object_size,

   244

                        "DefaultData" : defaultData,

   245

                        "Access": object_access, 

   246

                        "PDOMapping": object_PDOMapping_data}

   247

   248

        for TxPdo in self.getTxPdo():

   249

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

   250

        for RxPdo in self.getRxPdo():

   251

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

   252

   253

        return entries

   254

    setattr(cls, "GetEntriesList", GetEntriesList)

   255

   256

#    def GetEntriesList(self, limits=None):

   257

#        entries = {}

   258

   259

#        factory = EntryListFactory(entries)

   260

   261

#        entries_list_xslt_tree = etree.XSLT(

   262

#            entries_list_xslt, extensions = {

   263

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

   264

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

   265

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

   266

#        entries_list_xslt_tree(self, **dict(zip(

   267

#            ["min_index", "max_index"], 

   268

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

   269

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

   270

#            )))

   271

#        

   272

#        return entries

   273

#    setattr(cls, "GetEntriesList", GetEntriesList)

   274

   275

    def GetSyncManagers(self):

   276

        sync_managers = []

   277

        for sync_manager in self.getSm():

   278

            sync_manager_infos = {}

   279

            for name, value in [("Name", sync_manager.getcontent()),

   280

                                ("Start Address", sync_manager.getStartAddress()),

   281

                                ("Default Size", sync_manager.getDefaultSize()),

   282

                                ("Control Byte", sync_manager.getControlByte()),

   283

                                ("Enable", sync_manager.getEnable())]:

   284

                if value is None:

   285

                    value = ""

   286

                sync_manager_infos[name] = value

   287

            sync_managers.append(sync_manager_infos)

   288

        return sync_managers

   289

    setattr(cls, "GetSyncManagers", GetSyncManagers)

   290

   291

   292

def GroupItemCompare(x, y):

   293

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

   294

        if x["type"] == ETHERCAT_GROUP:

   295

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

   296

        else:

   297

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

   298

    elif x["type"] == ETHERCAT_GROUP:

   299

        return -1

   300

    return 1

   301

   302

   303

def SortGroupItems(group):

   304

    for item in group["children"]:

   305

        if item["type"] == ETHERCAT_GROUP:

   306

            SortGroupItems(item)

   307

    group["children"].sort(GroupItemCompare)

   308

   309

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

   310

    pdo_index = pdo.getIndex().getcontent()

   311

    pdo_name = ExtractName(pdo.getName())

   312

    exclude = pdo.getExclude()

   313

    for pdo_entry in pdo.getEntry():

   314

        entry_index = pdo_entry.getIndex().getcontent()

   315

        entry_subindex = pdo_entry.getSubIndex()

   316

        index = ExtractHexDecValue(entry_index)

   317

        subindex = ExtractHexDecValue(entry_subindex)

   318

        object_size = pdo_entry.getBitLen()

   319

   320

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

   321

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

   322

            if entry is not None:

   323

                entry["PDO index"] = pdo_index

   324

                entry["PDO name"] = pdo_name

   325

                entry["PDO type"] = pdo_type

   326

            else:

   327

                entry_type = pdo_entry.getDataType()

   328

                if entry_type is not None:

   329

                    if pdo_type == "Transmit":

   330

                        access = "ro"

   331

                        pdomapping = "T"

   332

                    else:

   333

                        access = "wo"

   334

                        pdomapping = "R"

   335

                    entries[(index, subindex)] = {

   336

                        "Index": entry_index,

   337

                        "SubIndex": entry_subindex,

   338

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

   339

                        "Type": entry_type.getcontent(),

   340

                        "BitSize": object_size,

   341

                        "Access": access,

   342

                        "PDOMapping": pdomapping}

   343

   344

class ModulesLibrary(object):

   345

   346

    MODULES_EXTRA_PARAMS = [

   347

        (

   348

            "pdo_alignment",

   349

            {

   350

                "column_label": _("PDO alignment"),

   351

                "column_size": 150,

   352

                "default": 8,

   353

                "description": _("Minimal size in bits between 2 pdo entries")

   354

            }

   355

        ),

   356

        (

   357

            "max_pdo_size",

   358

            {

   359

                "column_label": _("Max entries by PDO"),

   360

                "column_size": 150,

   361

                "default": 255,

   362

                "description": _("""Maximal number of entries mapped in a PDO

   363

including empty entries used for PDO alignment""")

   364

            }

   365

        ),

   366

        (

   367

            "add_pdo",

   368

            {

   369

                "column_label": _("Creating new PDO"),

   370

                "column_size": 150,

   371

                "default": 0,

   372

                "description": _("""Adding a PDO not defined in default configuration

   373

for mapping needed location variables

   374

(1 if possible)""")

   375

            }

   376

        )

   377

    ]

   378

   379

    def __init__(self, path, parent_library=None):

   380

        self.Path = path

   381

        if not os.path.exists(self.Path):

   382

            os.makedirs(self.Path)

   383

        self.ParentLibrary = parent_library

   384

   385

        if parent_library is not None:

   386

            self.LoadModules()

   387

        else:

   388

            self.Library = None

   389

        self.LoadModulesExtraParams()

   390

   391

    def GetPath(self):

   392

        return self.Path

   393

   394

    def GetModulesExtraParamsFilePath(self):

   395

        return os.path.join(self.Path, "modules_extra_params.cfg")

   396

   397

    groups_xpath = EtherCATInfo_XPath("Descriptions/Groups/Group")

   398

    devices_xpath = EtherCATInfo_XPath("Descriptions/Devices/Device")

   399

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

   400

   401

    def LoadModules(self):

   402

        self.Library = {}

   403

        # add by jblee for Modular Device Profile

   404

        self.MDPList = []

   405

        self.ModuleList = []

   406

        self.MDPEntryList = {}

   407

        dtDic = {}

   408

        self.idxIncrement = 0

   409

        self.slotIncrement = 0

   410

        # add by jblee for PDO Mapping

   411

        self.DataTypes = {}

   412

        self.ObjectDictionary = {}

   413

   414

        files = os.listdir(self.Path)

   415

        for file in files:

   416

            filepath = os.path.join(self.Path, file)

   417

            if os.path.isfile(filepath) and os.path.splitext(filepath)[-1] == ".xml":

   418

                self.modules_infos = None

   419

   420

                xmlfile = open(filepath, 'r')

   421

                try:

   422

                    self.modules_infos, error = EtherCATInfoParser.LoadXMLString(xmlfile.read())

   423

                    # if error is not None:

   424

                    #     self.GetCTRoot().logger.write_warning(

   425

                    #         XSDSchemaErrorMessage % (filepath + error))

   426

                except Exception as exc:

   427

                    self.modules_infos, error = None, str(exc)

   428

                xmlfile.close()

   429

   430

                if self.modules_infos is not None:

   431

                    vendor = self.modules_infos.getVendor()

   432

   433

                    vendor_category = self.Library.setdefault(

   434

                        ExtractHexDecValue(vendor.getId()),

   435

                        {"name": ExtractName(vendor.getName(), _("Miscellaneous")),

   436

                         "groups": {}})

   437

   438

                    for group in self.groups_xpath(self.modules_infos):

   439

                        group_type = group.getType()

   440

                        # add for XmlToEeprom Func by jblee.

   441

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

   442

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

   443

   444

                        vendor_category["groups"].setdefault(

   445

                            group_type,

   446

                            {

   447

                                "name": ExtractName(group.getName(), group_type),

   448

                                "parent": group.getParentGroup(),

   449

                                "order": group.getSortOrder(),

   450

                                "devices": [],

   451

                                # add jblee for support Moduler Device Profile (MDP)

   452

                                "modules": []})

   453

                            })

   454

   455

                    for device in self.devices_xpath(self.modules_infos):

   456

                        device_group = device.getGroupType()

   457

                        if device_group not in vendor_category["groups"]:

   458

                            raise ValueError("Not such group \"%s\"" % device_group)

   459

                        vendor_category["groups"][device_group]["devices"].append(

   460

                            (device.getType().getcontent(), device))

   461

   462

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

   463

                        slots = device.getSlots()

   464

                        if slots is not None:

   465

                            for slot in slots.getSlot():

   466

                                self.idxIncrement = slot.getSlotIndexIncrement()

   467

                                self.slotIncrement = slot.getSlotPdoIncrement()

   468

                                for child in slot.getchildren():

   469

                                    if child.tag == "ModuleClass":

   470

                                        child_class = child.getClass()

   471

                                        child_name = child.getName()

   472

   473

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

   474

                        LocalMDPList = []

   475

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

   476

                            module_type = module.getType().getModuleClass()

   477

                            module_name = module.getName()

   478

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

   479

   480

                            self.ModuleList.append(module)

   481

                            try :

   482

                                module_pdos = module.getTxPdo()

   483

                                module_pdos += module.getRxPdo()

   484

                                for module_pdo in module_pdos:

   485

                                    device_name = ExtractName(module_name)

   486

                                    pdo_index = module_pdo.getIndex().getcontent()

   487

                                    pdo_name = ExtractName(module_pdo.getName())

   488

                                    pdo_entry = module_pdo.getEntry()

   489

                                    if module_pdo.tag == "TxPdo":